Audiobooks_deep_learning.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8ASeNLcrwubX"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from sklearn import preprocessing\n",
        "import tensorflow as tf"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rmCwH2-yxXl7"
      },
      "outputs": [],
      "source": [
        "# Load the dataset\n",
        "data = np.loadtxt('Audiobooks_data.csv', delimiter=',')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bVoS-ulnyLtD"
      },
      "outputs": [],
      "source": [
        "# This is a hack to avoid having to re - calculate weights when a cluster is split.\n",
        "unscaled_inputs_all = data[:, 1:-1]\n",
        "targets_all = data[:, -1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wmjmhTZAzDXZ"
      },
      "outputs": [],
      "source": [
        "# Remove zero - target nodes. This is done by checking the number of targets in targets_all to see if there are zero - target nodes\n",
        "num_one_targets = int(np.sum(targets_all))\n",
        "zero_target_counter = 0 # Count the number of zero targets\n",
        "indices_to_remove = []\n",
        "\n",
        "for i in range(targets_all.shape[0]):\n",
        "  if targets_all[i] == 0:\n",
        "    zero_target_counter += 1\n",
        "    if zero_target_counter > num_one_targets:\n",
        "      indices_to_remove.append(i)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tGM3hWhv0DD4"
      },
      "outputs": [],
      "source": [
        "# Remove the excess zero targets\n",
        "unscaled_inputs_equal_priors = np.delete(unscaled_inputs_all, indices_to_remove, axis=0)\n",
        "targets_equal_priors = np.delete(targets_all, indices_to_remove, axis=0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9rVC4dkY0aM1"
      },
      "outputs": [],
      "source": [
        "# Scale unscaled inputs to equal priors. This is useful for preprocessing that has been applied to a batch\n",
        "scaled_inputs = preprocessing.scale(unscaled_inputs_equal_priors)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9LCYl0Co0pjF"
      },
      "outputs": [],
      "source": [
        "# Randomly shuffle the nodes and compute the targets. This is useful for testing and to avoid shuffling\n",
        "suffled_indices = np.arange(scaled_inputs.shape[0])\n",
        "np.random.shuffle(suffled_indices)\n",
        "shuffled_inputs = scaled_inputs[suffled_indices]\n",
        "targets_shuffled = targets_equal_priors[suffled_indices]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gEIw7bEr1nKq",
        "outputId": "b67ffbdc-2f00-48f1-eadd-4031e1765cc3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(3579, 10) (3579,) (447, 10) (447,) (448, 10) (448,)\n"
          ]
        }
      ],
      "source": [
        "# Split the dataset into training validation and test sets and split the dataset into training, validation and test sets\n",
        "samples_count = shuffled_inputs.shape[0]\n",
        "\n",
        "train_samples_count = int(0.8 * samples_count)\n",
        "validation_samples_count = int(0.1 * samples_count)\n",
        "test_samples_count = samples_count - train_samples_count - validation_samples_count\n",
        "\n",
        "train_inputs = shuffled_inputs[:train_samples_count]\n",
        "train_targets = targets_shuffled[:train_samples_count]\n",
        "\n",
        "validation_inputs = shuffled_inputs[train_samples_count:train_samples_count+validation_samples_count]\n",
        "validation_targets = targets_shuffled[train_samples_count:train_samples_count+validation_samples_count]\n",
        "\n",
        "test_inputs = shuffled_inputs[train_samples_count+validation_samples_count:]\n",
        "test_targets = targets_shuffled[train_samples_count+validation_samples_count:]\n",
        "\n",
        "print(train_inputs.shape, train_targets.shape, validation_inputs.shape, validation_targets.shape, test_inputs.shape, test_targets.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b-1hAlsh2_4N"
      },
      "outputs": [],
      "source": [
        "# Save Audiobooks data to npz files for use in tests. This is a helper function to avoid having to re - write the code\n",
        "np.savez('Audiobooks_data_train', inputs=train_inputs, targets=train_targets)\n",
        "np.savez('Audiobooks_data_validation', inputs=validation_inputs, targets=validation_targets)\n",
        "np.savez('Audiobooks_data_test', inputs=test_inputs, targets=test_targets)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iC-yUnnE4YTm"
      },
      "outputs": [],
      "source": [
        "# This is a copy of Audiobooks_data_test. npz but with a different\n",
        "npz = np.load('Audiobooks_data_train.npz')\n",
        "train_inputs = npz['inputs'].astype(np.float32)\n",
        "train_targets = npz['targets'].astype(np.int32)\n",
        "\n",
        "npz= np.load('Audiobooks_data_validation.npz')\n",
        "validation_inputs = npz['inputs'].astype(np.float32)\n",
        "validation_targets = npz['targets'].astype(np.int32)\n",
        "\n",
        "npz = np.load('Audiobooks_data_test.npz')\n",
        "test_inputs = npz['inputs'].astype(np.float32)\n",
        "test_targets = npz['targets'].astype(np.int32)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_m7rgE515UAF"
      },
      "outputs": [],
      "source": [
        "# Creates a Sequential model that can be used to train and test consensus. The input_size is the number of features in the input layer\n",
        "input_size = 10\n",
        "output_size = 2\n",
        "hidden_layer_size = 50\n",
        "\n",
        "model = tf.keras.Sequential([\n",
        "    tf.keras.layers.Dense(hidden_layer_size, activation='relu'),\n",
        "    tf.keras.layers.Dense(hidden_layer_size, activation='relu'),\n",
        "    tf.keras.layers.Dense(hidden_layer_size, activation='relu'),\n",
        "    tf.keras.layers.Dense(hidden_layer_size, activation='relu'),\n",
        "    tf.keras.layers.Dense(hidden_layer_size, activation='relu'),\n",
        "    tf.keras.layers.Dense(output_size, activation='softmax')\n",
        "])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "G5nVO6EW6NvJ"
      },
      "outputs": [],
      "source": [
        "# Compile and return Keras optimizer\n",
        "model. compile to avoid having to recompile\n",
        "optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001)\n",
        "model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cY6AOaqi6t1F",
        "outputId": "a3c8c71b-1ce6-4928-ddb2-1d680daa8bdb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/100\n",
            "36/36 - 1s - loss: 0.6863 - accuracy: 0.5407 - val_loss: 0.6708 - val_accuracy: 0.6734 - 1s/epoch - 38ms/step\n",
            "Epoch 2/100\n",
            "36/36 - 0s - loss: 0.6623 - accuracy: 0.6868 - val_loss: 0.6489 - val_accuracy: 0.7204 - 103ms/epoch - 3ms/step\n",
            "Epoch 3/100\n",
            "36/36 - 0s - loss: 0.6342 - accuracy: 0.7184 - val_loss: 0.6202 - val_accuracy: 0.7472 - 126ms/epoch - 3ms/step\n",
            "Epoch 4/100\n",
            "36/36 - 0s - loss: 0.5991 - accuracy: 0.7527 - val_loss: 0.5852 - val_accuracy: 0.7315 - 120ms/epoch - 3ms/step\n",
            "Epoch 5/100\n",
            "36/36 - 0s - loss: 0.5596 - accuracy: 0.7488 - val_loss: 0.5480 - val_accuracy: 0.7360 - 123ms/epoch - 3ms/step\n",
            "Epoch 6/100\n",
            "36/36 - 0s - loss: 0.5191 - accuracy: 0.7625 - val_loss: 0.5125 - val_accuracy: 0.7517 - 105ms/epoch - 3ms/step\n",
            "Epoch 7/100\n",
            "36/36 - 0s - loss: 0.4830 - accuracy: 0.7765 - val_loss: 0.4794 - val_accuracy: 0.7606 - 117ms/epoch - 3ms/step\n",
            "Epoch 8/100\n",
            "36/36 - 0s - loss: 0.4530 - accuracy: 0.7793 - val_loss: 0.4549 - val_accuracy: 0.7651 - 104ms/epoch - 3ms/step\n",
            "Epoch 9/100\n",
            "36/36 - 0s - loss: 0.4306 - accuracy: 0.7902 - val_loss: 0.4394 - val_accuracy: 0.7763 - 119ms/epoch - 3ms/step\n",
            "Epoch 10/100\n",
            "36/36 - 0s - loss: 0.4133 - accuracy: 0.7966 - val_loss: 0.4224 - val_accuracy: 0.8009 - 113ms/epoch - 3ms/step\n",
            "Epoch 11/100\n",
            "36/36 - 0s - loss: 0.4014 - accuracy: 0.7952 - val_loss: 0.4133 - val_accuracy: 0.8031 - 117ms/epoch - 3ms/step\n",
            "Epoch 12/100\n",
            "36/36 - 0s - loss: 0.3906 - accuracy: 0.8125 - val_loss: 0.4047 - val_accuracy: 0.8121 - 121ms/epoch - 3ms/step\n",
            "Epoch 13/100\n",
            "36/36 - 0s - loss: 0.3817 - accuracy: 0.8055 - val_loss: 0.4022 - val_accuracy: 0.8076 - 113ms/epoch - 3ms/step\n",
            "Epoch 14/100\n",
            "36/36 - 0s - loss: 0.3751 - accuracy: 0.8089 - val_loss: 0.3951 - val_accuracy: 0.7987 - 115ms/epoch - 3ms/step\n",
            "Epoch 15/100\n",
            "36/36 - 0s - loss: 0.3688 - accuracy: 0.8108 - val_loss: 0.3879 - val_accuracy: 0.8143 - 103ms/epoch - 3ms/step\n",
            "Epoch 16/100\n",
            "36/36 - 0s - loss: 0.3627 - accuracy: 0.8184 - val_loss: 0.3874 - val_accuracy: 0.8031 - 118ms/epoch - 3ms/step\n",
            "Epoch 17/100\n",
            "36/36 - 0s - loss: 0.3591 - accuracy: 0.8167 - val_loss: 0.3845 - val_accuracy: 0.8009 - 112ms/epoch - 3ms/step\n",
            "Epoch 18/100\n",
            "36/36 - 0s - loss: 0.3554 - accuracy: 0.8217 - val_loss: 0.3850 - val_accuracy: 0.8076 - 119ms/epoch - 3ms/step\n",
            "Epoch 19/100\n",
            "36/36 - 0s - loss: 0.3533 - accuracy: 0.8167 - val_loss: 0.3774 - val_accuracy: 0.7987 - 106ms/epoch - 3ms/step\n",
            "Epoch 20/100\n",
            "36/36 - 0s - loss: 0.3526 - accuracy: 0.8170 - val_loss: 0.3743 - val_accuracy: 0.8143 - 122ms/epoch - 3ms/step\n",
            "Epoch 21/100\n",
            "36/36 - 0s - loss: 0.3461 - accuracy: 0.8203 - val_loss: 0.3743 - val_accuracy: 0.8054 - 104ms/epoch - 3ms/step\n",
            "Epoch 22/100\n",
            "36/36 - 0s - loss: 0.3440 - accuracy: 0.8206 - val_loss: 0.3746 - val_accuracy: 0.8031 - 114ms/epoch - 3ms/step\n",
            "Epoch 23/100\n",
            "36/36 - 0s - loss: 0.3415 - accuracy: 0.8175 - val_loss: 0.3712 - val_accuracy: 0.8076 - 117ms/epoch - 3ms/step\n",
            "Epoch 24/100\n",
            "36/36 - 0s - loss: 0.3393 - accuracy: 0.8240 - val_loss: 0.3721 - val_accuracy: 0.8121 - 118ms/epoch - 3ms/step\n",
            "Epoch 25/100\n",
            "36/36 - 0s - loss: 0.3384 - accuracy: 0.8215 - val_loss: 0.3694 - val_accuracy: 0.8143 - 120ms/epoch - 3ms/step\n",
            "Epoch 26/100\n",
            "36/36 - 0s - loss: 0.3376 - accuracy: 0.8226 - val_loss: 0.3712 - val_accuracy: 0.8031 - 105ms/epoch - 3ms/step\n",
            "Epoch 27/100\n",
            "36/36 - 0s - loss: 0.3351 - accuracy: 0.8187 - val_loss: 0.3675 - val_accuracy: 0.8009 - 101ms/epoch - 3ms/step\n",
            "Epoch 28/100\n",
            "36/36 - 0s - loss: 0.3336 - accuracy: 0.8265 - val_loss: 0.3679 - val_accuracy: 0.8076 - 98ms/epoch - 3ms/step\n",
            "Epoch 29/100\n",
            "36/36 - 0s - loss: 0.3309 - accuracy: 0.8206 - val_loss: 0.3647 - val_accuracy: 0.8166 - 109ms/epoch - 3ms/step\n",
            "Epoch 30/100\n",
            "36/36 - 0s - loss: 0.3291 - accuracy: 0.8279 - val_loss: 0.3678 - val_accuracy: 0.8054 - 107ms/epoch - 3ms/step\n",
            "Epoch 31/100\n",
            "36/36 - 0s - loss: 0.3281 - accuracy: 0.8245 - val_loss: 0.3636 - val_accuracy: 0.8121 - 103ms/epoch - 3ms/step\n",
            "Epoch 32/100\n",
            "36/36 - 0s - loss: 0.3266 - accuracy: 0.8276 - val_loss: 0.3684 - val_accuracy: 0.8076 - 102ms/epoch - 3ms/step\n",
            "Epoch 33/100\n",
            "36/36 - 0s - loss: 0.3250 - accuracy: 0.8296 - val_loss: 0.3665 - val_accuracy: 0.7987 - 102ms/epoch - 3ms/step\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<keras.src.callbacks.History at 0x7b91da21dea0>"
            ]
          },
          "execution_count": 44,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Trains and returns the model\n",
        "batch_size = 100\n",
        "max_epochs = 100\n",
        "\n",
        "early_stopping = tf.keras.callbacks.EarlyStopping(patience=2)\n",
        "\n",
        "model.fit(train_inputs, train_targets, batch_size=batch_size, epochs=max_epochs, validation_data=(validation_inputs, validation_targets), callbacks=[early_stopping], verbose=2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZpqIIaKs7a-9",
        "outputId": "55c96a98-5a77-46fb-c7c0-82bc68f25bd4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "14/14 [==============================] - 0s 2ms/step - loss: 0.3416 - accuracy: 0.8125\n"
          ]
        }
      ],
      "source": [
        "# Tests the model on test_inputs and test_targets. Returns test_loss and test_accuracy\n",
        "test_loss, test_accuracy = model.evaluate(test_inputs, test_targets)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zyPvHf7JBaOl",
        "outputId": "526713fb-4866-41df-b7c8-6f4b165cf784"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test loss: 0.34. Test Accuracy: 81.25%\n"
          ]
        }
      ],
      "source": [
        "# Prints test loss and accuracy to standard output\n",
        "print('Test loss: {0:.2f}. Test Accuracy: {1:.2f}%'.format(test_loss, test_accuracy * 100.))"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}