Assignment2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment 2: Solving memory task using the RNN\n",
    "This exercise \n",
    "1. Reuses the bptt-rnn from ex1\n",
    "2. Implements a generator for the memory-task, so the label is the 0th element of an otherwise random sequence\n",
    "3. Implement a learner with MSE loss to test it\n",
    "4. Test learner with various parameters\n",
    "5. Visualize learning and MSE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "from typing import Tuple, Generator, Dict, List\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNN(object):\n",
    "    \"\"\"Numpy implementation of sequence-to-one recurrent neural network for regression tasks.\"\"\"\n",
    "    \n",
    "    def __init__(self, input_size: int, hidden_size: int, output_size: int):\n",
    "        \"\"\"Initialization \n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        input_size : int\n",
    "            Number of input features per time step\n",
    "        hidden_size : int\n",
    "            Number of hidden units in the RNN\n",
    "        output_size : int\n",
    "            Number of output units.\n",
    "        \"\"\"\n",
    "        super(RNN, self).__init__()\n",
    "        self.input_size = input_size\n",
    "        self.hidden_size = hidden_size\n",
    "        self.output_size = output_size\n",
    "\n",
    "        # create and initialize weights of the network\n",
    "        self.W = np.zeros((input_size, hidden_size))\n",
    "        self.R = np.zeros((hidden_size, hidden_size))\n",
    "        self.bs = np.zeros((hidden_size, 1))\n",
    "        self.V = np.zeros((hidden_size, output_size))\n",
    "        self.by = np.zeros((output_size, 1))\n",
    "        self.reset_parameters()\n",
    "\n",
    "        # place holder to store intermediates for backprop\n",
    "        self.a = None\n",
    "        self.y_hat = None\n",
    "        self.grads = None\n",
    "        self.x = None\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        \"\"\"Weight initialization\n",
    "        \n",
    "        Initialize the recurrent weights as identity matrix and the input to hidden\n",
    "        and hidden to output weights using the LeCun initialization.\n",
    "        \"\"\"\n",
    "        # recurrent weights initialized as identity matrix\n",
    "        self.R = np.eye(self.hidden_size)\n",
    "        \n",
    "        # input to hidden and hidden to output initialized with LeCun initialization\n",
    "        gain = np.sqrt(3 / self.input_size)\n",
    "        self.W = np.random.uniform(-gain, gain, self.W.shape)\n",
    "        gain = np.sqrt(3 / self.hidden_size)\n",
    "        self.V = np.random.uniform(-gain, gain, self.V.shape)\n",
    "\n",
    "    def forward(self, x: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Forward pass through the RNN.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        x : np.ndarray\n",
    "            Input sequence(s) of shape [sequence length, batch size, number of features]\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        NumPy array containing the network prediction for each sample in the input data.\n",
    "        \"\"\"\n",
    "        seq_length, batch_size, _ = x.shape\n",
    "\n",
    "        self.a = np.zeros((seq_length+1, batch_size, self.hidden_size))\n",
    "\n",
    "        a_0 = np.zeros((batch_size, self.hidden_size))\n",
    "        self.a[-1] = a_0.copy()\n",
    "\n",
    "        for t in range(seq_length):\n",
    "            s_t = x[t] @ self.W + self.a[t-1] @ self.R + self.bs.T\n",
    "            self.a[t] = np.tanh(s_t)\n",
    "        \n",
    "        y_hat = self.a[t] @ self.V + self.by.T\n",
    "        self.y_hat = y_hat.copy()\n",
    "        self.x = x.copy()\n",
    "\n",
    "        return y_hat\n",
    "\n",
    "    def backward(self, d_loss: np.ndarray) -> Dict:\n",
    "        \"\"\"Calculate the backward pass through the RNN.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        d_loss : np.ndarray\n",
    "            The gradient of the loss w.r.t the network output in the shape [batch_size, output_size]\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        Dictionary containing the gradients for each network weight as key-value pair.\n",
    "        \"\"\"\n",
    "        seq_length, _, _ = self.x.shape\n",
    "\n",
    "        # track gradients of weight matrices\n",
    "        d_V = np.zeros_like(self.V)\n",
    "        d_by = np.zeros_like(self.by)\n",
    "        d_R = np.zeros((seq_length, *self.R.shape))\n",
    "        d_W = np.zeros((seq_length, *self.W.shape))\n",
    "        d_bs = np.zeros((seq_length, *self.bs.shape))\n",
    "        \n",
    "        for t in reversed(range(seq_length)):\n",
    "            if t == seq_length - 1:\n",
    "                d_V = self.a[t].T @ d_loss\n",
    "                d_a = d_loss @ self.V.T\n",
    "                d_by = d_loss.sum(axis=0).reshape(self.by.shape)\n",
    "            else:\n",
    "                d_a = d_a_next\n",
    "            \n",
    "            d_s = d_a * (1 - self.a[t]**2)\n",
    "            d_W[t] = self.x[t].T @ d_s\n",
    "            d_R[t] = self.a[t-1].T @ d_s\n",
    "            d_bs[t] = d_s.sum(axis=0).reshape(d_bs[t].shape)\n",
    "\n",
    "            d_a_next = d_s @ self.R.T\n",
    "\n",
    "        self.grads = {'d_V': d_V, 'd_W': d_W, 'd_R': d_R, 'd_bs': d_bs, 'd_by': d_by}\n",
    "        \n",
    "        return self.grads\n",
    "        \n",
    "    def update(self, lr: float):\n",
    "        \"\"\"Updat the network parameter.\n",
    "        \n",
    "        Note: By convention (for numerical stabilization) the average (instead\n",
    "        of the sum) gradient over time is used for updating the recurrent weights.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        lr : float\n",
    "            Learning rate used for the weight update\n",
    "        \"\"\"\n",
    "        if not self.grads:\n",
    "            raise RuntimeError(\"You have to call the .backward() function first\")\n",
    "            \n",
    "        for key, grad in self.grads.items():\n",
    "            if len(grad.shape) == 3:\n",
    "                self.grads[key] = grad.sum(axis=0)\n",
    "                \n",
    "        self.W -= lr*self.grads['d_W']\n",
    "        self.R -= lr*self.grads['d_R']\n",
    "        self.V -= lr*self.grads['d_V']\n",
    "        self.bs -= lr*self.grads['d_bs']\n",
    "        self.by -= lr*self.grads['d_by']\n",
    "\n",
    "        # reset internal class attributes\n",
    "        self.grads = {}\n",
    "        self.y_hat, self.a = None, None\n",
    "        \n",
    "    def get_weights(self) -> Dict:\n",
    "        \"\"\"Return dictionary containing the weight matrices\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        Dictionary containing the network weights as key-value pairs.\n",
    "        \"\"\"\n",
    "        return {'W': self.W, 'R': self.R, 'V': self.V, 'bs': self.bs, 'by': self.by}\n",
    "    \n",
    "    def set_weights(self, weights: Dict):\n",
    "        \"\"\"Set the network weights.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        weights : Dict\n",
    "            Dictionary containing one key-value pair for each network weight.\n",
    "        \"\"\"\n",
    "        if not all(name in weights.keys() for name in ['W', 'R', 'V']):\n",
    "            raise ValueError(\"Missing one of 'W', 'R', 'V' keys in the weight dictionary\")\n",
    "        self.W = weights[\"W\"]\n",
    "        self.R = weights[\"R\"]\n",
    "        self.V = weights[\"V\"]\n",
    "        self.bs = weights[\"bs\"]\n",
    "        self.by = weights[\"by\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implement Datagenerator\n",
    "Random sequence, label is the 0th element, so you have to perfectly remember the 0th element and ignore every following up input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_samples(batch_size: int, seq_length: int) -> Tuple[np.ndarray, np.ndarray]:\n",
    "    \"\"\"Data generator for memory task\n",
    "    \n",
    "    Note: Implement this function as a Python generator.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    batch_size : int\n",
    "        Number of samples in one batch\n",
    "    seq_length : int\n",
    "        Length of sequence of random numbers\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    x : np.ndarray\n",
    "        Array of shape [sequence length, batch size, 1], where each sample is a sequence\n",
    "        of random generated numbers between -1 and 1.\n",
    "    y : np.ndarray\n",
    "        Array of shape [batch size, 1], where each element i contains the label corresponding\n",
    "        to sample i of the input array. The label is the first element of the sequence.\n",
    "    \n",
    "    \"\"\"\n",
    "    while True:\n",
    "        x = np.random.uniform(-1.0, 1.0, (seq_length, batch_size, 1))\n",
    "        y = x[0,:,:]\n",
    "        yield (x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data generator works as expected\n"
     ]
    }
   ],
   "source": [
    "batch_size = 256\n",
    "seq_length = 20\n",
    "data_generator = generate_samples(batch_size=batch_size, seq_length=seq_length)\n",
    "x, y = next(data_generator)\n",
    "assert np.all(x[0,:,:] == y)\n",
    "assert x.shape[0] == seq_length\n",
    "assert x.shape[1] == batch_size\n",
    "assert x.shape[2] == 1\n",
    "assert y.shape[0] == x.shape[1]\n",
    "assert y.shape[1] == 1\n",
    "print(\"Data generator works as expected\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implement MSE Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MSELoss(object):\n",
    "    def __init__(self):\n",
    "        super(MSELoss, self).__init__()\n",
    "        self.y_hat = None\n",
    "        self.y_true = None\n",
    "        \n",
    "    def forward(self, y_hat: np.ndarray, y_true: np.ndarray) -> float:\n",
    "        \"\"\"Calculate the MSE loss\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        y_hat : np.ndarray\n",
    "            Array containing the network predictions of shape [batch_size, 1]\n",
    "        y_true : np.ndarray\n",
    "            Array containing the true values of shape [batch_size, 1]\n",
    "        \n",
    "        Returns:\n",
    "        The mean square error as a floating number.\n",
    "        \"\"\"\n",
    "        self.y_hat = y_hat\n",
    "        self.y_true = y_true       \n",
    "        diff = (y_true.T-y_hat.T)**2\n",
    "        return np.mean(diff.T)\n",
    "    \n",
    "    def backward(self) -> np.ndarray:\n",
    "        \"\"\"Calculate the backward pass of the MSE\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        The gradient w.r.t the network output of shape [batch_size, 1]\n",
    "        \"\"\"\n",
    "        if (self.y_hat is None) or (self.y_true is None):\n",
    "            raise RuntimeError(\"You have to call the .forward() function first\")\n",
    "            \n",
    "        return 2 * (self.y_hat - self.y_true) / len(y_hat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_numerical_gradient(loss_obj: MSELoss, y_hat: np.ndarray, y_true: np.ndarray,\n",
    "                           eps: float=1e-7) -> np.ndarray:\n",
    "    \"\"\"Calculate the two-sided numerical gradient approximation.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    loss_obj : MSELoss\n",
    "        The MSELoss object\n",
    "    y_hat : np.ndarray\n",
    "        The network prediction of shape [batch size, number of outputs]\n",
    "    y_true : np.ndarray\n",
    "        The true target values of shape [batch size, number of outputs]\n",
    "    eps : float\n",
    "        The pertubations applied to the network predictions, by default 1e-7\n",
    "   \n",
    "    Returns\n",
    "    -------\n",
    "    A NumPy array containing the numerically approximated gradients.\n",
    "    \"\"\"\n",
    "    numerical_gradients = np.zeros_like(y_hat)\n",
    "    #########################################################################\n",
    "    # TODO: Implement the two-sided numerical gradient approximation.       #\n",
    "    # The specifications of the in- and output are defined in the docstring.#                                                  #\n",
    "    #########################################################################    \n",
    "    batch_size = len(y_hat)\n",
    "    eye = np.eye(batch_size) * eps  # helper diagonal matrix filled with eps\n",
    "    for i in range(batch_size):\n",
    "        plus = loss_obj.forward(y_hat + eye[:,i:i+1], y_true)\n",
    "        minus = loss_obj.forward(y_hat - eye[:,i:i+1], y_true)\n",
    "        numerical_gradients[i,0] += (plus-minus) / (2 * eps)\n",
    "    return numerical_gradients\n",
    "\n",
    "\n",
    "def get_analytical_gradient(loss_obj: MSELoss, y_hat: np.ndarray, \n",
    "                            y_true: np.ndarray) -> np.ndarray:\n",
    "    \"\"\"Calculate the analytically derived gradients.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    loss_obj : MSELoss\n",
    "        The MSELoss object\n",
    "    y_hat : np.ndarray\n",
    "        The network prediction of shape [batch size, number of outputs]\n",
    "    y_true : np.ndarray\n",
    "        The true target values of shape [batch size, number of outputs]\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    A NumPy array containing the analytically derived gradients.\n",
    "    \"\"\"        \n",
    "    _ = loss_obj.forward(y_hat, y_true)\n",
    "    analytical_grads = loss_obj.backward()\n",
    "            \n",
    "    return analytical_grads\n",
    "\n",
    "            \n",
    "def gradient_check(loss_obj: MSELoss, y_hat: np.ndarray, y_true: np.ndarray, \n",
    "                   treshold: float = 1e-7):\n",
    "    \"\"\"Perform the gradient check.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    loss_obj : MSELoss\n",
    "        The MSELoss object\n",
    "    y_hat : np.ndarray\n",
    "        The network prediction of shape [batch size, number of outputs]\n",
    "    y_true : np.ndarray\n",
    "        The true target values of shape [batch size, number of outputs]\n",
    "    threshold : float\n",
    "        Threshold for the difference between the numerical and analytical gradients.\n",
    "        By default 10e-7.\n",
    "        \n",
    "    \"\"\"            \n",
    "    numerical_grads = get_numerical_gradient(loss_obj, y_hat, y_true)\n",
    "    analytical_grads = get_analytical_gradient(loss_obj, y_hat, y_true)\n",
    "\n",
    "    difference = np.linalg.norm(numerical_grads - analytical_grads)\n",
    "    if difference < treshold:\n",
    "        print(f\"Gradient check passed (difference {difference:.3e})\")\n",
    "    else:\n",
    "        print(f\"Gradient check failed (difference {difference:.3e})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gradient check passed (difference 1.144e-09)\n"
     ]
    }
   ],
   "source": [
    "loss_obj = MSELoss()\n",
    "y_hat = np.random.rand(256, 1)\n",
    "y_true = np.random.rand(256, 1)\n",
    "gradient_check(loss_obj, y_hat, y_true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Learner(object):\n",
    "    def __init__(self, model: RNN, loss_obj: MSELoss, data_generator: Generator):\n",
    "        \"\"\"The initialization method\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        model : RNN\n",
    "            An instance of the NumPy RNN implementation.\n",
    "        loss_obj: MSELoss\n",
    "            An instance of the mean squared error loss class.\n",
    "        data_generator : Generator\n",
    "            The data generator function implemented above\n",
    "        \"\"\"\n",
    "        self.model = model\n",
    "        self.loss_obj = loss_obj\n",
    "        self.data_generator = data_generator\n",
    "        \n",
    "        self.loss_values = {}\n",
    "        self.y_hats = None\n",
    "        self.y_trues = None\n",
    "        \n",
    "    def train(self, iter_steps: int, lr: float, log_steps: int = 50):\n",
    "        \"\"\"The training method.\n",
    "        \n",
    "        This function implements the training loop for a given number of\n",
    "        iteration steps.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        iter_steps : int\n",
    "            Number of training iteration steps.\n",
    "        lr : float\n",
    "            Learning rate used for the weight update.\n",
    "        log_steps : int\n",
    "            Interval to log the training loss, by default 50.\n",
    "        \"\"\"\n",
    "        if not self.loss_values:\n",
    "            start_step = 0\n",
    "        else:\n",
    "            start_step = list(self.loss_values.keys())[-1]\n",
    "        pbar = tqdm.tqdm_notebook(self.data_generator, total=iter_steps)\n",
    "        for x, y in pbar:\n",
    "            pbar.update()\n",
    "            if pbar.n < iter_steps:\n",
    "                y_hat = self.model.forward(x)\n",
    "                loss = self.loss_obj.forward(y_hat, y)\n",
    "                d_loss = self.loss_obj.backward()\n",
    "                grads = self.model.backward(d_loss)\n",
    "                self.model.update(lr)\n",
    "                \n",
    "                # log loss value\n",
    "                if (pbar.n == 1) or (pbar.n % log_steps == 0):\n",
    "                    self.loss_values[start_step + pbar.n] = loss\n",
    "                    pbar.set_postfix_str(f\"Loss: {loss:5f}\", refresh=False)\n",
    "            else:\n",
    "                tqdm.tqdm.write(\"finished training\")\n",
    "                break\n",
    "    \n",
    "    def make_predictions(self, n_batches: int) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        \"\"\"Calculate predictions for a given number of random batches.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        n_batches : int\n",
    "            Number of batches to get networks predictions for.\n",
    "            \n",
    "        Returns\n",
    "        -------\n",
    "        y_hats : np.ndarray\n",
    "            NumPy array containing the concatenated network predictions for all batches.\n",
    "        y_trues : np.ndarray\n",
    "            NumPy array containing the concatenated true labels for all batches.\n",
    "        \"\"\"\n",
    "        batch_size = len(next(self.data_generator)[1])\n",
    "        self.y_hats = np.zeros((n_batches, batch_size, self.model.output_size))\n",
    "        self.y_trues = np.zeros_like(self.y_hats)\n",
    "        for batch in range(n_batches):\n",
    "            x, self.y_trues[batch] = next(self.data_generator)\n",
    "            self.y_hats[batch] = model.forward(x)\n",
    "        return self.y_hats, self.y_trues\n",
    "                    \n",
    "    def plot_loss(self, figsize: Tuple[float, float]=(10, 8)):\n",
    "        \"\"\"Plot training loss curve.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        figsize : Tuple[float, float]\n",
    "            Matplotlib figure size, by default (10,8)\n",
    "        \"\"\"\n",
    "        if not self.loss_values:\n",
    "            raise RuntimeError(\"You have to train the network first.\")\n",
    "            \n",
    "        fig, ax = plt.subplots(figsize=figsize)\n",
    "        ax.plot(list(self.loss_values.keys()), list(self.loss_values.values()))\n",
    "        ax.set_xlabel(\"Weight updates\")\n",
    "        ax.set_ylabel(\"MSE\")\n",
    "    \n",
    "    def scatter_plot(self,figsize: Tuple[float, float]=(10, 8)):\n",
    "        \"\"\"Scatter plot of true vs predicted values.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        figsize : Tuple[float, float]\n",
    "            Matplotlib figure size, by default (10,8)\n",
    "        \"\"\"        \n",
    "        if any(val is None for val in [self.y_hats, self.y_trues]):\n",
    "            raise RuntimeError(\"Call the .make_predictions() method first\")\n",
    "    \n",
    "        fig, ax = plt.subplots(figsize=figsize)\n",
    "        ax.scatter(self.y_trues, self.y_hats)\n",
    "        ax.plot([-1,1], [-1,1], '--', color='k', zorder=0)\n",
    "        ax.set_xlabel(\"True values\")\n",
    "        ax.set_ylabel(\"Predicted values\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "56d5f89a9e1642948e1710935c6fe851",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = RNN(input_size=1, hidden_size=10, output_size=1)\n",
    "data_generator = generate_samples(batch_size=1024, seq_length=10)\n",
    "\n",
    "learner = Learner(model=model, loss_obj=loss_obj, data_generator=data_generator)\n",
    "learner.train(iter_steps=5000, lr=1e-2, log_steps=50)\n",
    "learner.plot_loss()\n",
    "_ = learner.make_predictions(n_batches=1)\n",
    "learner.scatter_plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train LSTMs with different sequence lengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6d128b0abc06421da70a4f85a54dd656",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3d7dc11fda364698b981156fdcd5f82c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0a1b7d6c0eb34656a3d257671642ad80",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2338eb9ed74f4ff38b7935a2358f962b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b64903426769450f8831e0d141253059",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7e86be9f0e1d4835ab6be82bff3fae6f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "32e87ac1e2464ffb8799dccc4e3aa6f8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dc981e32d769478aa638eac871c7075d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aca19126428949169c65d3e3c90799f3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0323826f7a274a549dd07b691456950e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2cac179413e4473b81f174879252cdd9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2270697a5dce4d10b40f84378b36370a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9a90178eb18a4d6c8933994e764440fa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2c753cd7d89d4c68bfff4611b6948499",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8abc5633ca4a48c6b0254ed37de31cd8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0c291a1964df46078b8dafcab9631053",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e4b6c0daa5a64a7896235cdbe5d4a944",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d0a542e6828246db8a32c81895c2334f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ea8f069f1ba240d6b51a09b8fa858859",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ad2337557a4f4e12b6496c5f633601b3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9c082abadf4d45249cebb48b19b0792b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9cecef55380c4c98a9164f2754943ad7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "01c331f3c83d46edb5e608a88353bf53",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a0882017270942c7afd179add5bd7649",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "580841ba802c43508d351f4547f9f7dc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    }
   ],
   "source": [
    "learners_rep = defaultdict(list)\n",
    "seq_lens = [2, 5, 10, 15, 20]\n",
    "for seq_len in seq_lens:\n",
    "    for _ in range(5): # repeat 5 times\n",
    "        model = RNN(input_size=1, hidden_size=10, output_size=1)\n",
    "        data_generator = generate_samples(batch_size=1024, seq_length=seq_len)\n",
    "\n",
    "        learner = Learner(model=model, loss_obj=loss_obj, data_generator=data_generator)\n",
    "        learner.train(iter_steps=3000, lr=1e-3, log_steps=50)\n",
    "        learner.make_predictions(n_batches=10)\n",
    "        learners_rep[seq_len].append(learner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualization of different parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-11-902d7f62b803>:61: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
      "  fig.show()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_loss(learners: Dict[int, List[Learner]], figsize: Tuple[float, float]=(10, 8)):\n",
    "    \"\"\"Plot training loss curves.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    learners: Dict[int, Learner]\n",
    "        A dictionary of seq_len : Learner\n",
    "    figsize : Tuple[float, float]\n",
    "        Matplotlib figure size, by default (10,8)\n",
    "    \"\"\"\n",
    "    fig, ax = plt.subplots(figsize=figsize)\n",
    "    for seq_len, learner in sorted(learners.items()):\n",
    "        # average over the loss-values (keys + values)\n",
    "        k = np.mean([list(l.loss_values.keys()) for l in learner], axis=0)\n",
    "        v = np.mean([list(l.loss_values.values()) for l in learner], axis=0)\n",
    "        ax.plot(k, v, label = \"seq_len=\"+str(seq_len))\n",
    "    ax.set_xlabel(\"Weight updates\")\n",
    "    ax.set_ylabel(\"MSE\")\n",
    "    ax.legend()\n",
    "\n",
    "def error_plot(learners: Dict[int, List[Learner]],figsize: Tuple[float, float]=(10, 8), nr_clusters=40):\n",
    "    \"\"\"Scatter plot of true vs predicted values.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    learners: Dict[int, Learner]\n",
    "        A dictionary of seq_len : Learner\n",
    "    figsize : Tuple[float, float]\n",
    "        Matplotlib figure size, by default (10,8)\n",
    "    \"\"\"\n",
    "    \n",
    "    for seq_len, learner in learners.items():\n",
    "        # take all 10 into account\n",
    "        y_trues = np.array([l.y_trues for l in learner]).flatten()\n",
    "        y_hats = np.array([l.y_hats for l in learner]).flatten()\n",
    "        # create a dict from y_true -> y flat\n",
    "        oth = {k:v for k,v in zip(y_trues, y_hats)}\n",
    "        # sort this dict\n",
    "        soth = {k: oth[k] for k in sorted(oth.keys())}\n",
    "\n",
    "        # split sorted keys and values into clusters\n",
    "        ytc = np.split(np.array(list(soth.keys())), nr_clusters)\n",
    "        yhc = np.split(np.array(list(soth.values())), nr_clusters)\n",
    "\n",
    "        # take cluster means for line-pos\n",
    "        x = np.mean(ytc, axis=1)\n",
    "        y = np.mean(yhc, axis=1)\n",
    "        # take std as measure of error, as mean+/-std\n",
    "        # shape(2,N): Separate - and + values for each bar. First row\n",
    "        yerr = np.stack((y-np.min(yhc, axis=1), -(y-np.max(yhc, axis=1))))\n",
    "        yvar = np.var(yhc, axis=1)\n",
    "\n",
    "        fig, ax = plt.subplots(figsize=figsize)\n",
    "        label = \"seq_len=\"+str(seq_len)\n",
    "        # errorbars for range\n",
    "        ax.errorbar(x, y, yerr=yerr, label = label)\n",
    "        # errorbars for variance in red\n",
    "        ax.errorbar(x, y, yerr=yvar, ecolor=\"red\")\n",
    "        ax.set_xlim([-1,1])\n",
    "        ax.set_ylim([-1,1])\n",
    "        fig.show()\n",
    "        ax.legend(loc='upper left')\n",
    "\n",
    "plot_loss(learners_rep)\n",
    "error_plot(learners_rep)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualization: Vanishing gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "465900df7eaf4c299900ffad41bd0516",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b8f247efb4e84950802c7deaa1bb22ad",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "195a60fb21bb453a8c1ba6330c96f452",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5cd1ce91341a4875897a11f308594bda",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "70f027e970374dd596b60f5bd1eca6ab",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ee5eba179e4146439fa3ddd79b358455",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cd92ac8d30d940dcada244521c7c86ed",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b69d8dd1d1194b2290488986a3f5f87b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0e8505e368724b16a4741f0cdddc75ea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3afc3746ddf84cd3a9a08815c6f391c4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8049710d3bf64887abf535b621fa7ecd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9577417b0cdd48fd94be302c17681a42",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "69c9730695ac4871977dfbb515073773",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9d7469126637458ebafa279041058464",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "41374e43ea664cf682ecc57e985bbcad",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished training\n"
     ]
    }
   ],
   "source": [
    "learners = {}\n",
    "for seq_len in range(1,31, 2): # steps of 2 to speed it up\n",
    "    model = RNN(input_size=1, hidden_size=10, output_size=1)\n",
    "    data_generator = generate_samples(batch_size=1024, seq_length=seq_len)\n",
    "\n",
    "    learner = Learner(model=model, loss_obj=loss_obj, data_generator=data_generator)\n",
    "    learner.train(iter_steps=3000, lr=1e-3, log_steps=50)\n",
    "    learner.make_predictions(n_batches=10)\n",
    "    learners[seq_len] = learner\n",
    "\n",
    "first_key = list(learners.keys())[0]\n",
    "learner = learners[first_key]\n",
    "avg_gradient = {\"d_\"+k: defaultdict(int) for k in learner.model.get_weights().keys()}\n",
    "for seq_len, learner in learners.items():\n",
    "    pred = learner.make_predictions(1)\n",
    "    for p in pred[0]:\n",
    "        grads = learner.model.backward(p)\n",
    "        for name, g in grads.items():\n",
    "            avg_gradient[name][seq_len] += np.mean(np.abs(g))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average weights\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"Average weights\")\n",
    "for name, g in avg_gradient.items():\n",
    "    plt.plot(list(g.keys()), list(g.values()), label=name)\n",
    "    plt.xlabel=\"Sequence length\"\n",
    "    plt.ylabel=\"Average weight\"\n",
    "    plt.legend()\n",
    "    plt.tick_params(axis='both',labelsize=14)\n",
    "    plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}