lstm_from_scratch.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zEmGL8dr3O-0"
      },
      "source": [
        "# Homework 7: Recurrent neuronal networks\n"
      ],
      "id": "zEmGL8dr3O-0"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zghxs69F3ae0"
      },
      "source": [
        "## Imports \n"
      ],
      "id": "zghxs69F3ae0"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bba7a5e6-8e83-44cc-a798-8317d9d7f0ea"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "\n",
        "sample_size = 80000\n",
        "seq_len = 5"
      ],
      "id": "bba7a5e6-8e83-44cc-a798-8317d9d7f0ea"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0PlHdEIB6L1u"
      },
      "source": [
        "## Generator Function\n",
        "Yields a random noise signal of specified size and a target."
      ],
      "id": "0PlHdEIB6L1u"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4m_I-Kuj4qLQ"
      },
      "outputs": [],
      "source": [
        "def integration_task(seq_length=5, num_samples=10000,):\n",
        "    \"\"\"\n",
        "    Yields a num_samples times a random noise signal of size seq_length and a target.\n",
        "    ## Params\n",
        "        - seq_length = size of random noise signal\n",
        "        - num_samples = number of random noise samples\n",
        "    \"\"\"\n",
        "    for i in range(num_samples):\n",
        "        ar = np.random.normal(size=(seq_length))\n",
        "        yield (np.expand_dims(ar,-1),np.expand_dims(int(ar.sum()>0),-1))"
      ],
      "id": "4m_I-Kuj4qLQ"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uNnB4nMU7TGD"
      },
      "source": [
        "## Wrapper Generator \n",
        "Internally iterates through integration_task."
      ],
      "id": "uNnB4nMU7TGD"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6fc1e636-dcdc-4579-b55c-a637197f0ccb"
      },
      "outputs": [],
      "source": [
        "def my_integration_task():\n",
        "    \"\"\"Internally iterates through integration_task function\"\"\"\n",
        "    for i in integration_task(5, sample_size):\n",
        "        yield i"
      ],
      "id": "6fc1e636-dcdc-4579-b55c-a637197f0ccb"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZylaLViY5CnT"
      },
      "source": [
        "## Preprocessing pipeline\n"
      ],
      "id": "ZylaLViY5CnT"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "94e1cc7a-06a9-4cad-85be-d2fc4110c538",
        "outputId": "c42e2edd-8802-4657-f971-c39d0769af2a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(8, 5, 1) <dtype: 'float32'> (8, 1) <dtype: 'int64'>\n"
          ]
        }
      ],
      "source": [
        "# Creating Tensorflow Dataset\n",
        "data = tf.data.Dataset.from_generator(my_integration_task,(tf.float32,tf.int64),(tf.TensorShape([5,1]), tf.TensorShape([1])))\n",
        "\n",
        "def pipeline(ds,ratio):\n",
        "    \"\"\"Preprocessing pipeline for Tensorflow data\"\"\"\n",
        "    # Splitting in train and test\n",
        "    train = ds.take(int(ratio*sample_size))\n",
        "    test = ds.skip(int(ratio*sample_size))\n",
        "    # Shuffle\n",
        "    train = train.shuffle(1000)\n",
        "    test = test.shuffle(1000)\n",
        "    # batch\n",
        "    train = train.batch(8)\n",
        "    test = test.batch(8)\n",
        "    #prefetch\n",
        "    train = train.prefetch(20)\n",
        "    test = test.prefetch(20)\n",
        "\n",
        "    # return preprocessed data\n",
        "    return train,test\n",
        "\n",
        "train_ds, test_ds = pipeline(data,.8) \n",
        "for a,b in train_ds.take(1):\n",
        "    print(a.shape,a.dtype,b.shape,b.dtype)"
      ],
      "id": "94e1cc7a-06a9-4cad-85be-d2fc4110c538"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yJ3AbvD43kzz"
      },
      "source": [
        "## LSTM Cell"
      ],
      "id": "yJ3AbvD43kzz"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "df4efbc7-fe08-46f1-9fa8-476873a2f32c"
      },
      "outputs": [],
      "source": [
        "class LSTM_Cell(tf.keras.layers.Layer):\n",
        "    \n",
        "    def __init__(self, units, kernel_regularizer=None ):\n",
        "        super(LSTM_Cell, self).__init__()\n",
        "        \n",
        "        self.units = units\n",
        "        \n",
        "        self.forget_layer = tf.keras.layers.Dense(units, \n",
        "                                                  kernel_regularizer=kernel_regularizer, \n",
        "                                                   activation=\"sigmoid\",\n",
        "                                                  bias_initializer='ones')\n",
        "        self.input_layer = tf.keras.layers.Dense(units, \n",
        "                                                  kernel_regularizer=kernel_regularizer, \n",
        "                                                 activation=\"sigmoid\")\n",
        "\n",
        "        self.candidates_layer = tf.keras.layers.Dense(units, \n",
        "                                                 kernel_regularizer=kernel_regularizer, \n",
        "                                                 activation=\"tanh\")\n",
        "        \n",
        "        self.output_layer = tf.keras.layers.Dense(units, \n",
        "                                                 kernel_regularizer=kernel_regularizer, \n",
        "                                                 activation=\"sigmoid\")\n",
        "\n",
        "    def call(self, input_t,hidden_state, cell_state):\n",
        "\n",
        "        con_input = np.concatenate([input_t,hidden_state],axis=1)\n",
        "\n",
        "        forget_mask = self.forget_layer(con_input)\n",
        "\n",
        "        cell_after_forget = tf.math.multiply(forget_mask,hidden_state)\n",
        "        \n",
        "        input_mask = self.input_layer(con_input)\n",
        "        candidates = self.candidates_layer(con_input)\n",
        "        new_cell_state = tf.math.add(cell_after_forget,tf.math.multiply(input_mask,candidates))\n",
        "        output_mask = self.output_layer(con_input)\n",
        "        \n",
        "        new_hidden_state = np.multiply(output_mask,tf.nn.tanh(new_cell_state))\n",
        "        \n",
        "        return new_hidden_state, new_cell_state"
      ],
      "id": "df4efbc7-fe08-46f1-9fa8-476873a2f32c"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "80CWt4WA3nUL"
      },
      "source": [
        "## LSTM Wrapper\n"
      ],
      "id": "80CWt4WA3nUL"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c20f4799-c788-40ab-a62e-2b406817013c"
      },
      "outputs": [],
      "source": [
        "class LSTMWrapper(tf.keras.layers.Layer):\n",
        "    \n",
        "    def __init__(self, LSTM_Cell):\n",
        "        super(LSTMWrapper, self).__init__()\n",
        "        \n",
        "        self.cell = LSTM_Cell\n",
        "\n",
        "    def call(self, data, hs, cs):\n",
        "        out = []\n",
        "        hidden_state = hs\n",
        "        cell_state = cs\n",
        "        for t in range(seq_len):\n",
        "            hidden_state, cell_state = self.cell(data[:,t,:], hidden_state,cell_state)\n",
        "            out.append(hidden_state)\n",
        "        \n",
        "        return out\n",
        "\n",
        "    def zeros(self, batch_size):\n",
        "        return tf.zeros((batch_size, self.cell.units), dtype=tf.float32)"
      ],
      "id": "c20f4799-c788-40ab-a62e-2b406817013c"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FhhnNYLW3qEU"
      },
      "source": [
        "## Model"
      ],
      "id": "FhhnNYLW3qEU"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0182759b-ad8e-48b1-8dac-4c91358788f2"
      },
      "outputs": [],
      "source": [
        "class RNN_Model(tf.keras.Model):\n",
        "\n",
        "    def __init__(self):\n",
        "        super(RNN_Model, self).__init__()\n",
        "        self.input_ly = tf.keras.layers.Dense(units=seq_len, activation='sigmoid')\n",
        "        self.LSTM =  LSTMWrapper(LSTM_Cell(2))\n",
        "        self.output_ly = tf.keras.layers.Dense(units=1, activation='sigmoid')\n",
        "\n",
        "    def call(self,data):\n",
        "        x = self.input_ly(data)\n",
        "        x= self.LSTM(x,self.LSTM.zeros(8),self.LSTM.zeros(8))\n",
        "        return [self.output_ly(val) for val in x]"
      ],
      "id": "0182759b-ad8e-48b1-8dac-4c91358788f2"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y7jzxXhJ3r2n"
      },
      "source": [
        "## Train and Test function\n",
        "The training and test function are the same as last week. "
      ],
      "id": "Y7jzxXhJ3r2n"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2e44c93e-e889-4454-a535-8091df3ba649"
      },
      "outputs": [],
      "source": [
        "def train_step(model, input, target, loss_function, optimizer):\n",
        "    \"\"\"\n",
        "    Function for model training\n",
        "    ## Params\n",
        "        - model = instance of MyModel class\n",
        "        - input = input for model \n",
        "        - target = targets\n",
        "        - loss_function = loss function\n",
        "        - optimizer = tensorflow optimizer\n",
        "    \"\"\"\n",
        "    with tf.GradientTape() as tape:\n",
        "        prediction = model(input)[-1]\n",
        "        loss = loss_function(target, prediction)\n",
        "        gradients = tape.gradient(loss, model.trainable_variables, \n",
        "                unconnected_gradients=tf.UnconnectedGradients.ZERO)\n",
        "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
        "    return loss\n",
        "\n",
        "def test(model, test_data, loss_function):\n",
        "    \"\"\"\n",
        "    Function for model testing \n",
        "    ## Params\n",
        "        - model = instance of MyModel class\n",
        "        - test_data = data for testing\n",
        "        - loss_function = loss function\n",
        "    \"\"\"\n",
        "    # we use numpy array here to speed things up\n",
        "    test_accuracy_aggregator = np.empty(0)\n",
        "    test_loss_aggregator = np.empty(0)\n",
        "\n",
        "    for (input, target) in test_data:\n",
        "        prediction = model(input)[-1]\n",
        "        sample_test_loss = loss_function(target, prediction)\n",
        "        sample_test_accuracy = target == np.round(prediction,0) # accuracy computation for binary task\n",
        "        test_loss_aggregator = np.append(test_loss_aggregator, sample_test_loss.numpy())\n",
        "        test_accuracy_aggregator = np.append(test_accuracy_aggregator, np.mean(sample_test_accuracy))\n",
        "\n",
        "    test_loss = tf.reduce_mean(test_loss_aggregator)\n",
        "    test_accuracy = tf.reduce_mean(test_accuracy_aggregator)\n",
        "\n",
        "    return test_loss, test_accuracy"
      ],
      "id": "2e44c93e-e889-4454-a535-8091df3ba649"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GAvHKdsH35Z3"
      },
      "source": [
        "## Running our Code"
      ],
      "id": "GAvHKdsH35Z3"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "k6U523y7vbdU",
        "outputId": "e5649bf9-efbd-4ec4-bc30-b613024f839c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 0 starting with accuracy 0.40325000\n",
            "Epoch 1 starting with accuracy 0.64625000\n",
            "Epoch 2 starting with accuracy 0.64443750\n",
            "Epoch 3 starting with accuracy 0.64093750\n",
            "Epoch 4 starting with accuracy 0.64581250\n"
          ]
        }
      ],
      "source": [
        "tf.keras.backend.clear_session()\n",
        "\n",
        "# define hyperparams\n",
        "learning_rate = tf.constant(0.001, dtype=tf.float64) # A smaller learning rate prooved to be more useful\n",
        "num_epochs = 5\n",
        "model = RNN_Model()\n",
        "loss_func = tf.keras.losses.BinaryCrossentropy()\n",
        "optimizer = tf.optimizers.Adam(learning_rate)        # Adam yielded the most stable accuracies from all tested optimizers\n",
        "\n",
        "# arrays for later visualization\n",
        "# initial tests before training\n",
        "train_losses = np.empty(0)\n",
        "\n",
        "test_loss, test_acc = test(model, test_ds, loss_func)\n",
        "test_losses = np.array([test_loss])\n",
        "test_accuracies = np.array([test_acc])\n",
        "\n",
        "# model performance before training\n",
        "train_loss, _ = test(model, train_ds, loss_func)\n",
        "train_losses = np.append(train_losses, train_loss)\n",
        "\n",
        "# training of our model\n",
        "for epoch in range(num_epochs):\n",
        "    print(f'Epoch {str(epoch)} starting with accuracy {test_accuracies[-1]:.8f}')\n",
        "\n",
        "    epoch_loss_agg = np.empty(0)\n",
        "    for input, target in train_ds:\n",
        "        train_loss = train_step(model, input, target, loss_func, optimizer)\n",
        "        epoch_loss_agg = np.append(epoch_loss_agg, train_loss)\n",
        "\n",
        "    train_losses = np.append(train_losses, tf.reduce_mean(epoch_loss_agg))\n",
        "\n",
        "    test_loss, test_acc = test(model, test_ds, loss_func)\n",
        "    test_losses = np.append(test_losses, test_loss)\n",
        "    test_accuracies = np.append(test_accuracies, test_acc)"
      ],
      "id": "k6U523y7vbdU"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QK9B_ZIC3_jL"
      },
      "source": [
        "## Visualization"
      ],
      "id": "QK9B_ZIC3_jL"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "ksseuxrB2kkp",
        "outputId": "87277d63-257b-4cfc-b74d-d1263ecf4689"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x576 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot  as plt\n",
        "\n",
        "#Graph\n",
        "plt.figure(figsize=(18,8))\n",
        "plt.plot(range(num_epochs+1),test_losses,label=\"Test Losses\")\n",
        "plt.plot(range(num_epochs+1),train_losses, label=\"Train losses\")\n",
        "plt.plot(range(num_epochs+1),test_accuracies, label = \"Test accuracy\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "id": "ksseuxrB2kkp"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "0ivl5oZxDOIF",
        "outputId": "efc04871-15a9-484a-c1e9-f20f2a1a652b"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Barplot\n",
        "fig = plt.figure(figsize=(8, 6))\n",
        "ax = fig.add_axes([0,0,1,1])\n",
        "epochs = np.arange(6)\n",
        "label1 = ax.bar(epochs-0.3, test_losses, 0.3)\n",
        "label2 = ax.bar(epochs, train_losses, 0.3)\n",
        "label3 = ax.bar(epochs+0.3, test_accuracies, 0.3)\n",
        "plt.legend([label1, label2, label3], [\"test loss\", \"train loss\", \"accuracy\"])\n",
        "ax.set_title('Training')\n",
        "ax.set_ylabel('Loss and accuracies')\n",
        "ax.set_xlabel('Training steps')\n",
        "ax.set_xticks(np.arange(6))\n",
        "plt.show()"
      ],
      "id": "0ivl5oZxDOIF"
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "name": "mirreichts!.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.8 (tensorflow)",
      "language": "python",
      "name": "gpu"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.11"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}