RecirculationAlgorithm.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "RecirculationAlgorithm.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/amingolnari/Learning-Representations-by-Recirculation/blob/main/RecirculationAlgorithm.ipynb)"
      ],
      "metadata": {
        "id": "5QTiaCor3J_n"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "***A simple autoencoder implementation using recirculation algorithm which presented by:***\n",
        "\n",
        "# **LEARNING REPRESENTATIONS BY RECIRCULATION**\n",
        "\n",
        "**Geoffrey E. Hinton**\n",
        "\n",
        "* *Computer Science and Psychology Departments, University of Toronto, \n",
        "Toronto M5S lA4, Canada*\n",
        "\n",
        "**James L. McClelland** \n",
        "\n",
        "* *Psychology and Computer Science Departments, Carnegie-Mellon University, \n",
        "Pittsburgh, PA 15213*\n",
        "\n",
        "***Note: You can read the abstract and download the original paper at the end of this file.***"
      ],
      "metadata": {
        "id": "0UfV2-toZK8B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Import requirements**"
      ],
      "metadata": {
        "id": "6Nk3KyAoS_H0"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "d2Ym4Rvh_18B"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from tqdm import tqdm\n",
        "from typing import Union\n",
        "import numpy.typing as npt\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Update Matplotlib parameters for a better representation**"
      ],
      "metadata": {
        "id": "rKA3hSadTOJH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.style.use('seaborn')\n",
        "plt.rcParams.update({'figure.figsize': [10., 6.], 'font.size': 20, 'axes.titlesize': 20, 'axes.labelsize': 20, \n",
        "                     'xtick.labelsize': 20, 'ytick.labelsize': 20, 'legend.fontsize': 20})"
      ],
      "metadata": {
        "id": "ah4iuY1J5MLH"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Define a method to add threshold**"
      ],
      "metadata": {
        "id": "whoI2tiyTq9y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def thresh(x, shape, thr = 1):\n",
        "    \"\"\"\n",
        "    :param x:\n",
        "        -- list or numpy-array\n",
        "    input array to insert threshold for each nodes\n",
        "    :param shape:\n",
        "        -- integer\n",
        "    The shape of input\n",
        "    :param thr:\n",
        "        -- float or int\n",
        "    Desired value for inserting threshold to each node\n",
        "    :return:\n",
        "    \"\"\"\n",
        "    if type(x) == list:\n",
        "        x = np.asarray(x)\n",
        "    if len(list(x.shape)) == 1:\n",
        "        x = x.reshape((1, shape))\n",
        "    return np.append(x, np.asarray([[thr]]*x.shape[0]).reshape(x.shape[0], 1), axis = 1)"
      ],
      "metadata": {
        "id": "-c8gGX3gEBcc"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Define a class for implimenting recirculation algorithm**"
      ],
      "metadata": {
        "id": "kkht5GhMT3X5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Recirculation:\n",
        "    def __init__(self, input_shape: int, hidden_units: Union[int, list] = 4, activation: str = 'linear', learning_rate: float = 1., regression_rate: float = .75):\n",
        "        \"\"\"\n",
        "        :param input_shape:\n",
        "            -- integer (The shape of the input)\n",
        "        The input shape should be 1D, so you have to pass the input_shape to the class as an integer.\n",
        "        :param hidden_units:\n",
        "            -- integer, list or (1D) numpy-array. (The number of hidden units and layers)\n",
        "        This parameter specifies the number of layers and number of neurons in each layer. You will have just one layer with an\n",
        "        N-number nodes if you set it as an integer N. Otherwise, You will have a model with the number of layers equal to the length\n",
        "        of hidden_units, where each element represent the number of neurons in that layer if you set it as a list or an numpy-array.\n",
        "        default: 4\n",
        "        :param activation:\n",
        "            -- string (The activation function)\n",
        "        This parameter set an activation function to the layers. You have to pass it to the class as a string.\n",
        "        possible functions you can choose: {'linear', 'relu', 'sigmoid', 'tanh'}.\n",
        "        default: linear\n",
        "        :param learning_rate:\n",
        "            -- float (The learning rate)\n",
        "        You can set a learning rate by passing this parameter to the class. This parameter can be any but chose a float value.\n",
        "        default: 1.0\n",
        "        :param regression_rate:\n",
        "            -- float (The regression rate)\n",
        "        You can set a regression rate by passing this parameter to the class. This parameter can be any but chose a float value.\n",
        "        The paper mentioned it with a value of 0.75.\n",
        "        default: 0.75\n",
        "        :return:\n",
        "            -- Nothing! :-)\n",
        "        \"\"\"\n",
        "        list_of_activation_functions = ['sigmoid', 'relu', 'tanh', 'linear']\n",
        "        if activation not in list_of_activation_functions:\n",
        "            raise ValueError(f'You have to choose one of the following activation functions:\\n{list_of_activation_functions}\\nYou are trying to pass the parameter {activation}')\n",
        "        self.lr_ = learning_rate  # Set learning rate.\n",
        "        self.reg_ = regression_rate  # Set regression rate.\n",
        "\n",
        "        # Modifying hidden units shape by inserting output shape precisely as same as the input shape.\n",
        "        if type(hidden_units) == int:\n",
        "            hidden_units = np.append(np.asarray([hidden_units]), input_shape)\n",
        "        elif type(hidden_units) == list:\n",
        "            hidden_units.append(input_shape)\n",
        "        elif type(hidden_units).__name__ == 'ndarray':\n",
        "            hidden_units = np.append(hidden_units, input_shape)\n",
        "        else:\n",
        "            raise ValueError(f'You have to set the hidden_units parameter as type of list or integer. The type of parameter you are trying to pass is {type(hidden_units)}')\n",
        "        self.nh_ = np.asarray(hidden_units)\n",
        "\n",
        "        # Weight random initialization using a uniform distribution with values between -0.5 - +0.5.\n",
        "        self.w_ = [np.random.uniform(-.5, .5, (input_shape + 1, hidden_units[0]))]\n",
        "        for n in range(int(len(hidden_units) - 1)):\n",
        "            self.w_.append(np.random.uniform(-.5, .5, (hidden_units[n] + 1, hidden_units[n + 1])))\n",
        "\n",
        "        # Save mean squared error.\n",
        "        self.err = []\n",
        "\n",
        "        if activation == 'sigmoid':\n",
        "            self.acf_ = lambda x: 1 / (1 + np.exp(-x))  # Sigmoid output values are between 0-1.\n",
        "        elif activation == 'relu':\n",
        "            self.acf_ = lambda x: x * (x > 0)  # ReLU activation function ignores negative values you can use max(0, x).\n",
        "        elif activation == 'tanh':\n",
        "            self.acf_ = lambda x: np.tanh(x)  # Tanh output values are in the range -1 to 1.\n",
        "        elif activation == 'linear':\n",
        "            self.acf_ = lambda x: x  # Linear output values are exactly as same as the input.\n",
        "        self.acfn_ = activation\n",
        "\n",
        "    def fit(self, x_data: Union[list, npt.NDArray], epochs: int = 200):\n",
        "        \"\"\"\n",
        "        :param x_data:\n",
        "            -- list or (2D) numpy-array (The training data)\n",
        "        Input training data. You can pass the data as a list or 2D numpy-array to the class by setting this parameter.\n",
        "        :param epochs:\n",
        "            -- integer (The number of epochs for training phase)\n",
        "        The number of epoch for training phase.\n",
        "        :return:\n",
        "            -- list (Training reconstruction error history)\n",
        "        This function returns an array of mean squared errors per epoch.\n",
        "        \"\"\"\n",
        "        if len(list(x_data.shape)) > 2:\n",
        "            raise ValueError(f'The input data should be a 2D array such as the following data:\\n{np.eye(2)}\\nYou are trying to pass an input data with a shape of:\\n{x_data.shape}')\n",
        "        if epochs < 1:\n",
        "            raise ValueError(f'Please set the epochs as a positive integer greater than 1. You are trying to pass a parameter {epochs}!')\n",
        "        for _ in tqdm(range(epochs)):\n",
        "            # Computing the output of the layers at the first state.\n",
        "            temp_data = [x_data]\n",
        "            for n in range(len(self.nh_) - 1):\n",
        "                temp_data.append(self.acf_(thresh(temp_data[n], len(temp_data[n])) @ self.w_[n]))\n",
        "            # Approximating the gradient descent at the second state.\n",
        "            for n in range(len(self.nh_)):\n",
        "                temp_data.append((self.reg_ * temp_data[n]) + ((1 - self.reg_) * self.acf_(thresh(temp_data[n + len(self.nh_) - 1], len(temp_data[n])) @ self.w_[n - 1])))\n",
        "            # Update weights based on approximated GD.\n",
        "            for n in range(len(self.nh_)):\n",
        "                self.w_[n - 1] += self.lr_ * thresh(temp_data[n + len(self.nh_) - 1], len(temp_data[n])).T @ (temp_data[n] - temp_data[n + len(self.nh_)])\n",
        "            # Computing mean squared error. (The difference between the original and the reconstructed visible vector)\n",
        "            self.err.append(np.sum(((temp_data[len(self.nh_)] - temp_data[0]) ** 2) / 2))\n",
        "            del temp_data\n",
        "        return self.err\n",
        "\n",
        "    # This function returns layer weights based on the layer index.\n",
        "    def get_layer_weights(self, layer_index: int = -1):\n",
        "        \"\"\"\n",
        "        :param layer_index:\n",
        "            -- integer\n",
        "        This parameter gets the index of the layer to returns the weights of layer layer_index, so it should be an integer.\n",
        "        If you are going to get the weights of layer n, set this parameter to n.\n",
        "        :return:\n",
        "            -- list\n",
        "        The weights of layer layer_index.\n",
        "        \"\"\"\n",
        "        if layer_index > len(self.w_)-1:\n",
        "            raise ValueError(f'The index you have chosen is out of length. Maximum possible value for layer_index is {len(self.w_)-1}, you set layer_index to {layer_index}')\n",
        "        return self.w_[layer_index]\n",
        "\n",
        "    # This function returns layer output based on the layer index\n",
        "    def get_layer_output(self, x_data: Union[list, npt.NDArray], layer_index: int = -1):\n",
        "        \"\"\"\n",
        "        :param x_data:\n",
        "            -- list or (2D) numpy-array (The training data)\n",
        "        Input training data. You can pass the data as a list or 2D numpy-array to the class by setting this parameter.\n",
        "        :param layer_index:\n",
        "            -- integer\n",
        "        This parameter gets the index of the layer to returns the output of layer layer_index, so it should be an integer.\n",
        "        If you are going to get the weights of layer n, set this parameter to n.\n",
        "        :return:\n",
        "            -- layer output (and reconstruction error)\n",
        "        \"\"\"\n",
        "        if type(x_data) == list:\n",
        "            x_data = np.asarray(x_data)\n",
        "        if len(list(x_data.shape)) > 2:\n",
        "            raise ValueError(f'The input data should be a 2D array such as the following data:\\n{np.eye(2)}\\nYou are trying to pass an input data with a shape of:\\n{x_data.shape}')\n",
        "        if layer_index > len(self.nh_):\n",
        "            raise ValueError(f'The index you have chosen is out of length. Maximum possible value for layer_index is {len(self.nh_)}, you set layer_index to {layer_index}')\n",
        "        temp_data = [x_data]\n",
        "        for n in range(len(self.nh_)):\n",
        "            temp_data.append(self.acf_(thresh(temp_data[n], len(temp_data[n])) @ self.w_[n]))\n",
        "        return temp_data[layer_index]\n",
        "\n",
        "    # This function returns model output\n",
        "    def predict(self, testing_data: Union[list, npt.NDArray], get_logical: bool = True):\n",
        "        \"\"\"\n",
        "        :param testing_data:\n",
        "            -- list or numpy-array (The testing data)\n",
        "        Input testing data. You can pass the data as a list or 2D numpy-array to the class by setting this parameter.\n",
        "        Therefore you can get the output of the model according to the input of testing_data\n",
        "        :param get_logical:\n",
        "            -- boolean\n",
        "        If true, returns the actual output without decoding. Otherwise, returns decoded output using argmax\n",
        "        :return:\n",
        "            -- list\n",
        "        Calling this function returns the prediction of the model based on the testing_data\n",
        "        \"\"\"\n",
        "        if type(testing_data) == list:\n",
        "            x_data = np.asarray(testing_data)\n",
        "        if len(list(testing_data.shape)) > 2:\n",
        "            raise ValueError(f'The input data should be a 2D array such as the following data:\\n{np.eye(2)}\\nYou are trying to pass an input data with a shape of:\\n{testing_data.shape}')\n",
        "        temp_data = [testing_data]\n",
        "        for n in range(len(self.nh_)):  # If you are going to get logical output set get_logical = True\n",
        "            temp_data.append(self.acf_(thresh(temp_data[n], len(temp_data[n])) @ self.w_[n]))\n",
        "        if get_logical:\n",
        "            return np.eye(temp_data[-1].shape[1])[np.array([np.argmax(temp_data[-1], axis = 1)]).reshape(-1)]\n",
        "        else:\n",
        "            return temp_data[-1]\n",
        "\n",
        "    # By calling this function you can plot the training error\n",
        "    def plot_error(self):\n",
        "        \"\"\"\n",
        "        :return:\n",
        "            -- A graph shows mean squared error during training phase\n",
        "        \"\"\"\n",
        "        x = np.arange(1, len(self.err) + 1, step = 1)\n",
        "        plt.plot(x, self.err, label = 'MSE', linewidth = 2, color = 'r')\n",
        "        plt.axhline(y = .1, color = 'b', linestyle = '-.')\n",
        "        plt.vlines(x = 48, ymin = 0, ymax = self.err[47], color = 'g', linestyle = '-.')\n",
        "        plt.text(x = 49, y = self.err[47] * 1.01, s = f'Epoch: 48 - MSE: {self.err[47]:.4f}!')\n",
        "        plt.text(x = 10, y = .101, s = f'MSE: 0.1')\n",
        "        plt.title(f'Training History (Activation: {self.acfn_})')\n",
        "        plt.ylabel('Mean Squared Error')\n",
        "        plt.xlabel('Epoch')\n",
        "        plt.xticks(x[::9])\n",
        "        plt.xlim([0, 101])\n",
        "        plt.ylim([np.min(self.err) * .8, np.max(self.err) * 1.01])\n",
        "        plt.legend()\n",
        "        plt.show()"
      ],
      "metadata": {
        "id": "MNtAOf2TxYmH"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Set inputs as mentioned in the paper:**\n",
        "*   \"...The visible vectors were **1000**, **0100**, **0010** and **0001**...\"\n",
        "\n"
      ],
      "metadata": {
        "id": "_RgsAfV9UPzZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_data = np.eye(4)\n",
        "train_data"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lzW0UNSwxYkB",
        "outputId": "d27e3035-4b22-4fad-cee9-b5feaaee9709"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 0., 0., 0.],\n",
              "       [0., 1., 0., 0.],\n",
              "       [0., 0., 1., 0.],\n",
              "       [0., 0., 0., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Set Parameters of training according to page 363**\n",
        "\n",
        "Somewhere on page 363 have written:\n",
        "*   ... the 2 hidden units ...\n",
        "*   ... $\\lambda$ of 0.75 ... (Regression rate for estimating gradient descent state)\n",
        "*   ... $\\epsilon$ of 20 ... (Learning rate for training state. *Why the learning rate should be chosen that much high!!!*) \n",
        "* ... $\\sigma(x_{i}) = \\frac{1}{1+e^{-x_{i}}}$ ... (For hidden units we use the logistic \n",
        "function)"
      ],
      "metadata": {
        "id": "aiQf-oUpUvDg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "params = {\n",
        "    'input_shape':          train_data.shape[1],\n",
        "    'hidden_units':         2,\n",
        "    'activation_function':  'sigmoid',\n",
        "    'learning_rate':        1., \n",
        "    'regression_rate':      .75,\n",
        "    'epochs':               100\n",
        "}"
      ],
      "metadata": {
        "id": "S-VKTuaQ8QNf"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Pass arguments to the defined class**"
      ],
      "metadata": {
        "id": "282BtTn_WzLi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ac = Recirculation(input_shape = params['input_shape'], \n",
        "                   hidden_units = params['hidden_units'], \n",
        "                   activation = params['activation_function'], \n",
        "                   learning_rate = params['learning_rate'], \n",
        "                   regression_rate = params['regression_rate'])"
      ],
      "metadata": {
        "id": "ZOc5To_HxYhq"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Fit the model**"
      ],
      "metadata": {
        "id": "qEZjgK_jXG7Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hist = ac.fit(train_data, epochs = params['epochs'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "opfCQCq9QVoB",
        "outputId": "1ff27e13-ed8c-4408-b5e1-b422711162c5"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 100/100 [00:00<00:00, 3824.20it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Graph mean squared error over training**\n",
        "\n",
        "**-NOTE:** *According to my understanding of the paper, the error reached less than 0.1 at epoch 48, based on page 363!*\n",
        "\n",
        "*  *...reconstruction error of less than 0.1 on every unit in an **average** of 48 weight updates...*\n",
        "\n",
        "* ...*The squared reconstruction error, $E$:*\n",
        "\n",
        " $E = \\frac{1}{2}\\sum \\limits_{k}[y^{(2)}_{k}-y^{(0)}_{k}]^{2}$"
      ],
      "metadata": {
        "id": "jUK8ghFhXL0B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ac.plot_error()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 427
        },
        "id": "ltyMXjvOdsC-",
        "outputId": "1a0c6ff6-68be-4cea-8083-5c3e0d141a18"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x432 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Generate a test data**"
      ],
      "metadata": {
        "id": "ycnO8zYYDsyd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def gen_random_test_data(input_shape: int):\n",
        "    \"\"\"\n",
        "    :param input_shape:\n",
        "        -- integer\n",
        "    The shape of input data\n",
        "    :return:\n",
        "        -- numpy-array\n",
        "    This function returns random sample similar to the shape of the input data \n",
        "    \"\"\"\n",
        "    return np.eye(input_shape)[list(np.random.default_rng().choice(input_shape, np.random.randint(low = 1, high = input_shape + 1, size = 1), replace = False))]"
      ],
      "metadata": {
        "id": "xLIkevSFwVHd"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_data = gen_random_test_data(params['input_shape'])\n",
        "test_data"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ie_izci8D0X5",
        "outputId": "283a3c53-ae45-44e5-a0b4-9c633e47fdab"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 1., 0., 0.],\n",
              "       [0., 0., 1., 0.]])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Get the actual output of the model**"
      ],
      "metadata": {
        "id": "jaarZFSGXi9q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = ac.predict(testing_data = test_data, get_logical = False)\n",
        "y_pred"
      ],
      "metadata": {
        "id": "EVSCeN_ij4fm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f04d449d-65d6-4a91-80fe-4ac995458ecc"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.19175688, 0.2994169 , 0.25827688, 0.17526189],\n",
              "       [0.19620721, 0.33753755, 0.41551429, 0.12944357]])"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Get decoded (argmax) output of the model**"
      ],
      "metadata": {
        "id": "hGcxuMI_YSCO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = ac.predict(testing_data = test_data, get_logical = True)\n",
        "y_pred"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4O5t2CW6G45X",
        "outputId": "dde24ba3-3d4a-4895-8f27-3ae743957670"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 1., 0., 0.],\n",
              "       [0., 0., 1., 0.]])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The output of the hidden layer layer_index corresponding to the x_data**"
      ],
      "metadata": {
        "id": "ZvXhJKUMtJ_S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l_idx = 1\n",
        "x = [0, 1, 0, 0]\n",
        "hidden_output = ac.get_layer_output(x_data = x, layer_index = l_idx)"
      ],
      "metadata": {
        "id": "VGtBBoBrmdZV"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The weights related to the hidden layer layer_index**"
      ],
      "metadata": {
        "id": "D2zKmUQ41a1U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# If the hidden unit has an index of (n), then its weights has an index of (n - 1)\n",
        "w = ac.get_layer_weights(l_idx-1)"
      ],
      "metadata": {
        "id": "N4GNvrNnt383"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Hidden output using multiplying the input data by the extracted weights:\\n{ac.acf_(thresh(x, params['input_shape']) @ w)}\\n\\n\" + \n",
        "      f'Hidden output by calling method get_layer_output:\\n{hidden_output}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OxTMd02fzZFT",
        "outputId": "48ab487c-1b19-4d20-d12c-532d40612309"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hidden output using multiplying the input data by the extracted weights:\n",
            "[[0.53342023 0.7117894 ]]\n",
            "\n",
            "Hidden output by calling method get_layer_output:\n",
            "[[0.53342023 0.7117894 ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Yeah It Works! 😀 \n",
        "\n",
        "Have Fun... **1st rule of programming: If it works, don't touch it!**\n",
        "\n",
        "![weird.gif](data:image/gif;base64,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)"
      ],
      "metadata": {
        "id": "SfReppGyGzaM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**NOTE:** *Using a different activation function instead of logistic, provides a better answer! (Experimentally)*"
      ],
      "metadata": {
        "id": "tJKmD_MblOtl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **ABSTRACT**\n",
        "\n",
        "*We describe a new learning procedure for networks that contain groups of non- linear units arranged in a closed loop. The aim of  the learning  is to discover  codes that allow the activity vectors in a \"visible\" group to be  represented  by  activity vectors in a \"hidden\" group. One way to test whether a code is an accurate representation is to try to reconstruct the visible vector from the hidden vector. The difference between the original and the reconstructed visible vectors is called the reconstruction error, and ihe learning procedure aims to minimize this error. The learning procedure has two passes. On the first  pass,  the  original  visible  vector  is passed around the loop, and on the second pass an average of the origirial vector and the reconstructed vector is passed around  the  loop.  The  learning  procedure  changes each weight by an amount proportional to the product of the  \"presynaptic\"  activity and the difference in the post-synaptic activity on the two passes. This procedure is much simpler to implement than methods like back-propagation.  Simulations  in simple networks show that it usually converges rapidly on a good set of codes, and analysis shows that in certain restricted cases it performs gradient descent in  the squared reconstruction error.*\n",
        "\n",
        "**Paper link**\n",
        "\n",
        "https://proceedings.neurips.cc/paper/1987/file/35f4a8d465e6e1edc05f3d8ab658c551-Paper.pdf"
      ],
      "metadata": {
        "id": "SYz5S7qma9w7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "FmJ3-nKe4hs-"
      },
      "execution_count": 16,
      "outputs": []
    }
  ]
}