RNN_practicing_using_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing RNN using numpy\n",
    "#### state_t = 0\n",
    "#### for input_t in input_seq:\n",
    "####    output_t = activation(dot(W, input_t) + dot(U, state_t) + b)\n",
    "####    state_t = output_t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Time steps in the input sequence\n",
    "timesteps = 100\n",
    "# Dimensionality of the input feature space\n",
    "input_features = 32\n",
    "# Dimensionality of the output feature space\n",
    "output_features = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input data: random noise(ex)\n",
    "inputs = np.random.random((timesteps, input_features))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.08275519, 0.51161013, 0.09238195, ..., 0.65007907, 0.86014555,\n",
       "        0.28866389],\n",
       "       [0.75839164, 0.39495897, 0.97321624, ..., 0.36122942, 0.07986086,\n",
       "        0.82594281],\n",
       "       [0.92100636, 0.27234095, 0.40932533, ..., 0.08954832, 0.13164042,\n",
       "        0.44917422],\n",
       "       ...,\n",
       "       [0.70268481, 0.04455268, 0.69121535, ..., 0.08398066, 0.22789679,\n",
       "        0.10607419],\n",
       "       [0.59989933, 0.94838007, 0.51186239, ..., 0.91151982, 0.72823799,\n",
       "        0.72613753],\n",
       "       [0.68934514, 0.36401819, 0.89165333, ..., 0.63309941, 0.84660554,\n",
       "        0.716442  ]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#initial state: all zero vector\n",
    "state_t = np.zeros((output_features,))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating random weight matrices\n",
    "W = np.random.random((output_features, input_features))\n",
    "U = np.random.random((output_features, output_features))\n",
    "bais = np.random.random((output_features, ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(64, 32)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(W)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(64, 64)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(U)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "success_outputs = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#input_t is a vector of shape (input_features)\n",
    "for input_t in inputs:\n",
    "    # combining the input with the previous output to get the current output\n",
    "    output_t = np.tanh(np.dot(W, input_t) + np.dot(U, state_t) + bais)\n",
    "    #storing the output to new list\n",
    "    success_outputs.append(output_t)\n",
    "    #udpating the state of the network for the next timestep\n",
    "    state_t = output_t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#the final output is 2D tensor of shape (timesteps, output_features)\n",
    "final_out_sequence = np.concatenate(success_outputs, axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6400,)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(final_out_sequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6400"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(final_out_sequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.99999998, 0.99980265, 0.99999985, ..., 1.        , 1.        ,\n",
       "       1.        ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_out_sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}