recurrent_neural_networks.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled13.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyNsRFzS5GIkX6WNnqJvRdxF",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/binarybeastt/DSN-AI-bootcamp-hackathon/blob/main/recurrent_neural_networks.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "mrQSzCXu3KqD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5499b62f-79b8-424c-c57d-90b6231fe679"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%cd /content/drive/My\\ Drive\n",
        "\n",
        "# List files to make sure we're in the expected directory.\n",
        "# Your output will look different, showing your own Drive files here.\n",
        "!ls"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KwPyjk2bVhMs",
        "outputId": "d5d0f2c7-bd84-4aea-d9e5-29b8e49b7a07"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/My Drive\n",
            "'August Clearance.docx'\t\t\t     'Untitled document.gdoc'\n",
            "'BLACK BEAUTIES.gform'\t\t\t     'Untitled form (10).gform'\n",
            "'BUSINESS SUPPORT BUDGET FOR BULK SMS.gdoc'  'Untitled form (11).gform'\n",
            " Certificates\t\t\t\t     'Untitled form (12).gform'\n",
            "'Colab Notebooks'\t\t\t     'Untitled form (1).gform'\n",
            " Copy_of_fctweets.pdf\t\t\t     'Untitled form (2).gform'\n",
            " Datasets\t\t\t\t     'Untitled form (3).gform'\n",
            " Designs\t\t\t\t     'Untitled form (4).gform'\n",
            "'DSNhackathon.ipynb - Colaboratory.pdf'      'Untitled form (5).gform'\n",
            " fctweets.slides.html\t\t\t     'Untitled form (6).gform'\n",
            "'final year project.gdoc'\t\t     'Untitled form (7).gform'\n",
            "'Office Files'\t\t\t\t     'Untitled form (8).gform'\n",
            "'OLYMPUS TOKEN AIRDROP FORM .gform'\t     'Untitled form (9).gform'\n",
            "'Personal Statement.docx'\t\t     'Untitled form.gform'\n",
            " Screenshot_20211216-211532.png\t\t      week1\n",
            " Trees\t\t\t\t\t     'Week 1'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%cd Week\\ 1\n",
        "!ls"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "giNa0rQHV2_f",
        "outputId": "13a9951c-c7a9-47bf-e0bc-54beeb12f3d8"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/MyDrive/Week 1\n",
            "Images\trnn_utils.py  shakespeare.txt  Untitled13.ipynb  utils.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!ls -l rnn_utils.py\n",
        "from rnn_utils import *"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MaOBBCw7V_N-",
        "outputId": "dfbc9706-62a8-4ecd-d9ed-7e222b618f10"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-rw------- 1 root root 5155 Jun 12 12:15 rnn_utils.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np"
      ],
      "metadata": {
        "id": "ozCRd3c3WVAb"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def rnn_cell_forward(xt, a_prev, parameters):\n",
        "  \"\"\"\n",
        "  This function implements a single forward step of the RNN \n",
        "   Arguments:\n",
        "    xt -- your input data at timestep \"t\", numpy array of shape (n_x, m).\n",
        "    a_prev -- Hidden state at timestep \"t-1\", numpy array of shape (n_a, m)\n",
        "    parameters -- python dictionary containing:\n",
        "                        Wax -- Weight matrix multiplying the input, numpy array of shape (n_a, n_x)\n",
        "                        Waa -- Weight matrix multiplying the hidden state, numpy array of shape (n_a, n_a)\n",
        "                        Wya -- Weight matrix relating the hidden-state to the output, numpy array of shape (n_y, n_a)\n",
        "                        ba --  Bias, numpy array of shape (n_a, 1)\n",
        "                        by -- Bias relating the hidden-state to the output, numpy array of shape (n_y, 1)\n",
        "    Returns:\n",
        "    a_next -- next hidden state, of shape (n_a, m)\n",
        "    yt_pred -- prediction at timestep \"t\", numpy array of shape (n_y, m)\n",
        "    cache -- tuple of values needed for the backward pass, contains (a_next, a_prev, xt, parameters)\n",
        "  \"\"\"\n",
        "\n",
        "  #Retrieve parameters from parameters\n",
        "  Wax = parameters[\"Wax\"]\n",
        "  Waa = parameters[\"Waa\"]\n",
        "  Wya = parameters[\"Wya\"]\n",
        "  ba = parameters[\"ba\"]\n",
        "  by = parameters[\"by\"]\n",
        "\n",
        "  #compute next activation state using the formula\n",
        "  a_next = np.tanh(np.dot(Waa, a_prev)+np.dot(Wax, xt)+ba)\n",
        "  # compute output of the current cell using the formula given above\n",
        "  yt_pred = softmax(np.dot(Wya, a_next)+by)\n",
        "  # store values you need for backward propagation in cache\n",
        "  cache = (a_next, a_prev, xt, parameters)\n",
        "\n",
        "  return a_next, yt_pred, cache"
      ],
      "metadata": {
        "id": "6CwOutLJXd-I"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.seed(1)\n",
        "xt = np.random.randn(3,10)\n",
        "a_prev = np.random.randn(5,10)\n",
        "Waa = np.random.randn(5,5)\n",
        "Wax = np.random.randn(5,3)\n",
        "Wya = np.random.randn(2,5)\n",
        "ba = np.random.randn(5,1)\n",
        "by = np.random.randn(2,1)\n",
        "parameters = {\"Waa\": Waa, \"Wax\": Wax, \"Wya\": Wya, \"ba\": ba, \"by\": by}\n",
        "\n",
        "a_next, yt_pred, cache = rnn_cell_forward(xt, a_prev, parameters)\n",
        "print(\"a_next[4] = \", a_next[4])\n",
        "print(\"a_next.shape = \", a_next.shape)\n",
        "print(\"yt_pred[1] =\", yt_pred[1])\n",
        "print(\"yt_pred.shape = \", yt_pred.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M2PVCl6XaXpq",
        "outputId": "631c7119-0285-4820-8340-fb37a509465c"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a_next[4] =  [ 0.59584544  0.18141802  0.61311866  0.99808218  0.85016201  0.99980978\n",
            " -0.18887155  0.99815551  0.6531151   0.82872037]\n",
            "a_next.shape =  (5, 10)\n",
            "yt_pred[1] = [0.9888161  0.01682021 0.21140899 0.36817467 0.98988387 0.88945212\n",
            " 0.36920224 0.9966312  0.9982559  0.17746526]\n",
            "yt_pred.shape =  (2, 10)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def rnn_forward(x, a0, parameters):\n",
        "  \"\"\"\n",
        "    Implement the forward propagation of the recurrent neural network described in Figure (3).\n",
        "\n",
        "    Arguments:\n",
        "    x -- Input data for every time-step, of shape (n_x, m, T_x).\n",
        "    a0 -- Initial hidden state, of shape (n_a, m)\n",
        "    parameters -- python dictionary containing:\n",
        "                        Waa -- Weight matrix multiplying the hidden state, numpy array of shape (n_a, n_a)\n",
        "                        Wax -- Weight matrix multiplying the input, numpy array of shape (n_a, n_x)\n",
        "                        Wya -- Weight matrix relating the hidden-state to the output, numpy array of shape (n_y, n_a)\n",
        "                        ba --  Bias numpy array of shape (n_a, 1)\n",
        "                        by -- Bias relating the hidden-state to the output, numpy array of shape (n_y, 1)\n",
        "\n",
        "    Returns:\n",
        "    a -- Hidden states for every time-step, numpy array of shape (n_a, m, T_x)\n",
        "    y_pred -- Predictions for every time-step, numpy array of shape (n_y, m, T_x)\n",
        "    caches -- tuple of values needed for the backward pass, contains (list of caches, x)\n",
        "    \"\"\"\n",
        "\n",
        "    # Initialize \"caches\" which will contain the list of all caches\n",
        "  caches = []\n",
        "\n",
        "  # Retrieve dimensions from shapes of x and parameters[\"Wya\"]\n",
        "  n_x, m, T_x = x.shape\n",
        "  n_y, n_a = parameters[\"Wya\"].shape\n",
        "\n",
        "  #Initialize a and y with zeros\n",
        "  a = np.zeros((n_x, m, T_x))\n",
        "  y_pred = np.zeros((n_y, m, T_x))\n",
        "\n",
        "  #Initialize a_next\n",
        "  a_next = a0\n",
        "\n",
        "  #loop over all time-steps\n",
        "  for t in range(T_x):\n",
        "      # Update next hidden state, compute the prediction, get the cache (≈1 line)\n",
        "      a_next, yt_pred, cache = rnn_cell_forward(x[:,:,t], a_next, parameters)\n",
        "      # Save the value of the new \"next\" hidden state in a (≈1 line)\n",
        "      a[:,:,t] = a_next\n",
        "      # Save the value of the prediction in y (≈1 line)\n",
        "      y_pred[:,:,t] = yt_pred\n",
        "      # Append \"cache\" to \"caches\" (≈1 line)\n",
        "      caches.append(cache)\n",
        "\n",
        "  #store values needed for backpropagation in cache\n",
        "  caches = (cache, x)\n",
        "\n",
        "  return a, y_pred, caches\n"
      ],
      "metadata": {
        "id": "XmmujZaga-6D"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.seed(1)\n",
        "x = np.random.randn(3,10,4)\n",
        "a0 = np.random.randn(5,10)\n",
        "Waa = np.random.randn(5,5)\n",
        "Wax = np.random.randn(5,3)\n",
        "Wya = np.random.randn(2,5)\n",
        "ba = np.random.randn(5,1)\n",
        "by = np.random.randn(2,1)\n",
        "parameters = {\"Waa\": Waa, \"Wax\": Wax, \"Wya\": Wya, \"ba\": ba, \"by\": by}\n",
        "\n",
        "a, y_pred, caches = rnn_forward(x, a0, parameters)\n",
        "print(\"a[4][1] = \", a[4][1])\n",
        "print(\"a.shape = \", a.shape)\n",
        "print(\"y_pred[1][3] =\", y_pred[1][3])\n",
        "print(\"y_pred.shape = \", y_pred.shape)\n",
        "print(\"caches[1][1][3] =\", caches[1][1][3])\n",
        "print(\"len(caches) = \", len(caches))"
      ],
      "metadata": {
        "id": "VN5NuYqLexPl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2: Long Short Term Memory (LSTM) Network"
      ],
      "metadata": {
        "id": "xDDojaXZggjg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def lstm_cell_forward(xt, a_prev, c_prev, parameters):\n",
        "  \"\"\"\n",
        "  Implement a single forward step of the LSTM-cell as described in Figure (4)\n",
        "\n",
        "  Arguments:\n",
        "  xt -- your input data at timestep \"t\", numpy array of shape (n_x, m).\n",
        "  a_prev -- Hidden state at timestep \"t-1\", numpy array of shape (n_a, m)\n",
        "  c_prev -- Memory state at timestep \"t-1\", numpy array of shape (n_a, m)\n",
        "  parameters -- python dictionary containing:\n",
        "                      Wf -- Weight matrix of the forget gate, numpy array of shape (n_a, n_a + n_x)\n",
        "                      bf -- Bias of the forget gate, numpy array of shape (n_a, 1)\n",
        "                      Wi -- Weight matrix of the update gate, numpy array of shape (n_a, n_a + n_x)\n",
        "                      bi -- Bias of the update gate, numpy array of shape (n_a, 1)\n",
        "                      Wc -- Weight matrix of the first \"tanh\", numpy array of shape (n_a, n_a + n_x)\n",
        "                      bc --  Bias of the first \"tanh\", numpy array of shape (n_a, 1)\n",
        "                      Wo -- Weight matrix of the output gate, numpy array of shape (n_a, n_a + n_x)\n",
        "                      bo --  Bias of the output gate, numpy array of shape (n_a, 1)\n",
        "                      Wy -- Weight matrix relating the hidden-state to the output, numpy array of shape (n_y, n_a)\n",
        "                      by -- Bias relating the hidden-state to the output, numpy array of shape (n_y, 1)\n",
        "  Returns:\n",
        "  a_next -- next hidden state, of shape (n_a, m)\n",
        "  c_next -- next memory state, of shape (n_a, m)\n",
        "  yt_pred -- prediction at timestep \"t\", numpy array of shape (n_y, m)\n",
        "  cache -- tuple of values needed for the backward pass, contains (a_next, c_next, a_prev, c_prev, xt, parameters)\n",
        "  \n",
        "  Note: ft/it/ot stand for the forget/update/output gates, cct stands for the candidate value (c tilde),\n",
        "        c stands for the memory value\n",
        "  \"\"\" \n",
        "\n",
        "  # Retrieve parameters from \"parameters\"\n",
        "  Wf = parameters[\"Wf\"]\n",
        "  bf = parameters[\"bf\"]\n",
        "  Wi = parameters[\"Wi\"]\n",
        "  bi = parameters[\"bi\"]\n",
        "  Wc = parameters[\"Wc\"]\n",
        "  bc = parameters[\"bc\"]\n",
        "  Wo = parameters[\"Wo\"]\n",
        "  bo = parameters[\"bo\"]\n",
        "  Wy = parameters[\"Wy\"]\n",
        "  by = parameters[\"by\"]\n",
        "\n",
        "  # Retrieve dimensions from shapes of xt and Wy\n",
        "  n_x, m = xt.shape   #3,10\n",
        "  n_y, n_a = Wy.shape #2,5\n",
        "\n",
        "  ### START CODE HERE ###\n",
        "  # Concatenate a_prev and xt (≈3 lines)\n",
        "  concat = np.zeros([n_x+n_a,m])\n",
        "  concat[: n_a, :] = a_prev\n",
        "  concat[n_a :, :] = xt\n",
        "\n",
        "  # Compute values for ft, it, cct, c_next, ot, a_next using the formulas given figure (4) (≈6 lines)\n",
        "  ft = sigmoid(np.dot(Wf,concat)+bf)\n",
        "  it = sigmoid(np.dot(Wi,concat)+bi)\n",
        "  cct = np.tanh(np.dot(Wc,concat)+bc)\n",
        "  c_next = ft*c_prev+it*cct\n",
        "  ot = sigmoid(np.dot(Wo,concat)+bo)\n",
        "  a_next = ot*np.tanh(c_next)\n",
        "  \n",
        "  # Compute prediction of the LSTM cell (≈1 line)\n",
        "  yt_pred = softmax(np.dot(Wy,a_next)+by)\n",
        "  ### END CODE HERE ### \n",
        "\n",
        "  # store values needed for backward propagation in cache\n",
        "  cache = (a_next, c_next, a_prev, c_prev, ft, it, cct, ot, xt, parameters)\n",
        "\n",
        "  return a_next, c_next, yt_pred, cache                 "
      ],
      "metadata": {
        "id": "TqtaKgHBe5ib"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.seed(1)\n",
        "xt = np.random.randn(3,10)\n",
        "a_prev = np.random.randn(5,10)\n",
        "c_prev = np.random.randn(5,10)\n",
        "Wf = np.random.randn(5, 5+3)\n",
        "bf = np.random.randn(5,1)\n",
        "Wi = np.random.randn(5, 5+3)\n",
        "bi = np.random.randn(5,1)\n",
        "Wo = np.random.randn(5, 5+3)\n",
        "bo = np.random.randn(5,1)\n",
        "Wc = np.random.randn(5, 5+3)\n",
        "bc = np.random.randn(5,1)\n",
        "Wy = np.random.randn(2,5)\n",
        "by = np.random.randn(2,1)\n",
        "\n",
        "parameters = {\"Wf\": Wf, \"Wi\": Wi, \"Wo\": Wo, \"Wc\": Wc, \"Wy\": Wy, \"bf\": bf, \"bi\": bi, \"bo\": bo, \"bc\": bc, \"by\": by}\n",
        "\n",
        "a_next, c_next, yt, cache = lstm_cell_forward(xt, a_prev, c_prev, parameters)\n",
        "print(\"a_next[4] = \", a_next[4])\n",
        "print(\"a_next.shape = \", c_next.shape)\n",
        "print(\"c_next[2] = \", c_next[2])\n",
        "print(\"c_next.shape = \", c_next.shape)\n",
        "print(\"yt[1] =\", yt[1])\n",
        "print(\"yt.shape = \", yt.shape)\n",
        "print(\"cache[1][3] =\", cache[1][3])\n",
        "print(\"len(cache) = \", len(cache))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_p1N1zCLkRa9",
        "outputId": "69a76aeb-94a8-4451-e8a6-ac5d326ea3a0"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a_next[4] =  [-0.66408471  0.0036921   0.02088357  0.22834167 -0.85575339  0.00138482\n",
            "  0.76566531  0.34631421 -0.00215674  0.43827275]\n",
            "a_next.shape =  (5, 10)\n",
            "c_next[2] =  [ 0.63267805  1.00570849  0.35504474  0.20690913 -1.64566718  0.11832942\n",
            "  0.76449811 -0.0981561  -0.74348425 -0.26810932]\n",
            "c_next.shape =  (5, 10)\n",
            "yt[1] = [0.79913913 0.15986619 0.22412122 0.15606108 0.97057211 0.31146381\n",
            " 0.00943007 0.12666353 0.39380172 0.07828381]\n",
            "yt.shape =  (2, 10)\n",
            "cache[1][3] = [-0.16263996  1.03729328  0.72938082 -0.54101719  0.02752074 -0.30821874\n",
            "  0.07651101 -1.03752894  1.41219977 -0.37647422]\n",
            "len(cache) =  10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def lstm_forward(x, a0, parameters):\n",
        "  \"\"\"\n",
        "  Implement the forward propagation of the recurrent neural network using an LSTM-cell described in Figure (3).\n",
        "\n",
        "  Arguments:\n",
        "  x -- Input data for every time-step, of shape (n_x, m, T_x).\n",
        "  a0 -- Initial hidden state, of shape (n_a, m)\n",
        "  parameters -- python dictionary containing:\n",
        "                      Wf -- Weight matrix of the forget gate, numpy array of shape (n_a, n_a + n_x)\n",
        "                      bf -- Bias of the forget gate, numpy array of shape (n_a, 1)\n",
        "                      Wi -- Weight matrix of the update gate, numpy array of shape (n_a, n_a + n_x)\n",
        "                      bi -- Bias of the update gate, numpy array of shape (n_a, 1)\n",
        "                      Wc -- Weight matrix of the first \"tanh\", numpy array of shape (n_a, n_a + n_x)\n",
        "                      bc -- Bias of the first \"tanh\", numpy array of shape (n_a, 1)\n",
        "                      Wo -- Weight matrix of the output gate, numpy array of shape (n_a, n_a + n_x)\n",
        "                      bo -- Bias of the output gate, numpy array of shape (n_a, 1)\n",
        "                      Wy -- Weight matrix relating the hidden-state to the output, numpy array of shape (n_y, n_a)\n",
        "                      by -- Bias relating the hidden-state to the output, numpy array of shape (n_y, 1)\n",
        "                      \n",
        "  Returns:\n",
        "  a -- Hidden states for every time-step, numpy array of shape (n_a, m, T_x)\n",
        "  y -- Predictions for every time-step, numpy array of shape (n_y, m, T_x)\n",
        "  caches -- tuple of values needed for the backward pass, contains (list of all the caches, x)\n",
        "  \"\"\"\n",
        "\n",
        "  # Initialize \"caches\", which will track the list of all the caches\n",
        "  caches = []\n",
        "  \n",
        "  ### START CODE HERE ###\n",
        "  # Retrieve dimensions from shapes of x and parameters['Wy'] (≈2 lines)\n",
        "  n_x, m, T_x = x.shape              #(3,10,7)\n",
        "  n_y, n_a = parameters[\"Wy\"].shape  #(2,5)\n",
        "  \n",
        "  # initialize \"a\", \"c\" and \"y\" with zeros (≈3 lines)\n",
        "  a = np.zeros([n_a, m, T_x])\n",
        "  c = np.zeros([n_a, m, T_x])\n",
        "  y = np.zeros([n_y, m, T_x])\n",
        "  \n",
        "  # Initialize a_next and c_next (≈2 lines)\n",
        "  a_next = a0\n",
        "  c_next = c[:,:,0]\n",
        "  \n",
        "  # loop over all time-steps\n",
        "  for t in range(T_x):\n",
        "      # Update next hidden state, next memory state, compute the prediction, get the cache (≈1 line)\n",
        "      a_next, c_next, yt, cache = lstm_cell_forward(x[:,:,t], a_next, c_next, parameters)\n",
        "      # Save the value of the new \"next\" hidden state in a (≈1 line)\n",
        "      a[:,:,t] = a_next\n",
        "      # Save the value of the prediction in y (≈1 line)\n",
        "      y[:,:,t] = yt\n",
        "      # Save the value of the next cell state (≈1 line)\n",
        "      c[:,:,t]  = c_next\n",
        "      # Append the cache into caches (≈1 line)\n",
        "      caches.append(cache)\n",
        "\n",
        "  # store values needed for backward propagation in cache\n",
        "  caches = (caches, x)\n",
        "\n",
        "  return a, y, c, caches\n"
      ],
      "metadata": {
        "id": "mF-x8-ZolTAe"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.seed(1)\n",
        "x = np.random.randn(3,10,7)\n",
        "a0 = np.random.randn(5,10)\n",
        "Wf = np.random.randn(5, 5+3)\n",
        "bf = np.random.randn(5,1)\n",
        "Wi = np.random.randn(5, 5+3)\n",
        "bi = np.random.randn(5,1)\n",
        "Wo = np.random.randn(5, 5+3)\n",
        "bo = np.random.randn(5,1)\n",
        "Wc = np.random.randn(5, 5+3)\n",
        "bc = np.random.randn(5,1)\n",
        "Wy = np.random.randn(2,5)\n",
        "by = np.random.randn(2,1)\n",
        "\n",
        "parameters = {\"Wf\": Wf, \"Wi\": Wi, \"Wo\": Wo, \"Wc\": Wc, \"Wy\": Wy, \"bf\": bf, \"bi\": bi, \"bo\": bo, \"bc\": bc, \"by\": by}\n",
        "\n",
        "a, y, c, caches = lstm_forward(x, a0, parameters)\n",
        "print(\"a[4][3][6] = \", a[4][3][6])\n",
        "print(\"a.shape = \", a.shape)\n",
        "print(\"y[1][4][3] =\", y[1][4][3])\n",
        "print(\"y.shape = \", y.shape)\n",
        "print(\"caches[1][1[1]] =\", caches[1][1][1])\n",
        "print(\"c[1][2][1]\", c[1][2][1])\n",
        "print(\"len(caches) = \", len(caches))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a7cTACFhmVgt",
        "outputId": "97ddeabe-4c99-48bf-f917-c9c7bfa0c4d6"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a[4][3][6] =  0.17211776753291672\n",
            "a.shape =  (5, 10, 7)\n",
            "y[1][4][3] = 0.9508734618501101\n",
            "y.shape =  (2, 10, 7)\n",
            "caches[1][1[1]] = [ 0.82797464  0.23009474  0.76201118 -0.22232814 -0.20075807  0.18656139\n",
            "  0.41005165]\n",
            "c[1][2][1] -0.8555449167181981\n",
            "len(caches) =  2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "ttctsanSmtqJ"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}