GAN_usingNN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled6.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyNq5hMSQIMa8Vq1ANrh+AgN",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Preetika764/ML_Recruitment/blob/master/GAN_usingNN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jhgvRkESJmXv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 225
        },
        "outputId": "0146b44d-5f49-40c8-8855-a73f6e2776b0"
      },
      "source": [
        "!pip install numpy mnist matplotlib sklearn\n",
        "import numpy as np\n",
        "from matplotlib import pyplot as plt\n",
        "import mnist\n",
        "import matplotlib\n",
        "import os\n",
        "import matplotlib.gridspec as gridspec\n",
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn.utils import shuffle\n",
        "from sklearn.model_selection import train_test_split"
      ],
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (1.18.5)\n",
            "Requirement already satisfied: mnist in /usr/local/lib/python3.6/dist-packages (0.2.2)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.6/dist-packages (3.2.2)\n",
            "Requirement already satisfied: sklearn in /usr/local/lib/python3.6/dist-packages (0.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (1.2.0)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (2.8.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (0.10.0)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (2.4.7)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.6/dist-packages (from sklearn) (0.22.2.post1)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.6/dist-packages (from python-dateutil>=2.1->matplotlib) (1.12.0)\n",
            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.6/dist-packages (from scikit-learn->sklearn) (0.15.1)\n",
            "Requirement already satisfied: scipy>=0.17.0 in /usr/local/lib/python3.6/dist-packages (from scikit-learn->sklearn) (1.4.1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-3PvlgGOMEbn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "\n",
        "def cost_function(y_true, y_pred):\n",
        "    \"\"\"\n",
        "    Computes the Mean Square Error between a ground truth vector and a prediction vector\n",
        "    Parameters:\n",
        "    ---\n",
        "    y_true: ground-truth vector\n",
        "    y_pred: prediction vector\n",
        "    Returns:\n",
        "    ---\n",
        "    cost: a scalar value representing the loss\n",
        "    \"\"\"\n",
        "    n = y_pred.shape[1]\n",
        "    cost = (1./(2*n)) * np.sum((y_true - y_pred) ** 2)\n",
        "    return cost\n",
        "\n",
        "def cost_function_prime(y_true, y_pred):\n",
        "    \"\"\"\n",
        "    Computes the derivative of the loss function w.r.t the activation of the output layer\n",
        "    Parameters:\n",
        "    ---\n",
        "    y_true: ground-truth vector\n",
        "    y_pred: prediction vector\n",
        "    Returns:\n",
        "    ---\n",
        "    cost_prime: derivative of the loss w.r.t. the activation of the output\n",
        "    shape: (n[L], batch_size)\n",
        "    \"\"\"\n",
        "    \n",
        "    # Calculate the derivative of the cost function\n",
        "    \n",
        "    #derivative of cost_function \n",
        "    cost_prime = (y_pred - y_true)\n",
        "    return cost_prime"
      ],
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NnYutnGAMblP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 86
        },
        "outputId": "918a4296-2a6f-4f4e-9520-bf287d21cb27"
      },
      "source": [
        "X_train = mnist.train_images()\n",
        "y_train = mnist.train_labels()\n",
        "X_test = mnist.test_images()\n",
        "y_test = mnist.test_labels()\n",
        "\n",
        "X_train = X_train/255\n",
        "X_test = X_test/255\n",
        "\n",
        "X_train = X_train.reshape((-1,784))\n",
        "X_test = X_test.reshape((-1,784))\n",
        "y_train = y_train.reshape((-1,1))\n",
        "y_test = y_test.reshape((-1, 1))\n",
        "\n",
        "print(X_train.shape)\n",
        "print(X_test.shape)\n",
        "print(y_train.shape)\n",
        "print(y_test.shape)\n",
        "\n",
        "images = X_train\n",
        "labels = y_train\n",
        "\n",
        "#print(X_train.ndim)"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(60000, 784)\n",
            "(10000, 784)\n",
            "(60000, 1)\n",
            "(10000, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5joZUK67MgYS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "outputId": "28e5d2e3-2fee-4e78-dd5b-020a2c9183fc"
      },
      "source": [
        "x = X_train[7].reshape(28,28)\n",
        "plt.imshow(x, cmap='Greys')"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fe7d76cc6a0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 66
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "unfKj117RASk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "    \n",
        "def activation(x):\n",
        "    return 1 / ( 1+ np.exp(-1*x))\n",
        "def d_activation(x):\n",
        "    return activation(x) * (1 - activation(x))\n",
        "\n",
        "def plot(samples):\n",
        "    fig = plt.figure(figsize=(4, 4))\n",
        "    gs = gridspec.GridSpec(4, 4)\n",
        "    gs.update(wspace=0.05, hspace=0.05)\n",
        "\n",
        "    for i, sample in enumerate(samples):\n",
        "        ax = plt.subplot(gs[i])\n",
        "        plt.axis('off')\n",
        "        ax.set_xticklabels([])\n",
        "        ax.set_yticklabels([])\n",
        "        ax.set_aspect('equal')\n",
        "        plt.imshow(sample.reshape(28, 28), cmap='Greys_r')\n",
        "\n",
        "    return fig\n"
      ],
      "execution_count": 67,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ErBHj0_ML8GY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class NeuralNetwork(object):\n",
        "    '''\n",
        "    This is a custom neural netwok package built from scratch with numpy.\n",
        "    The Neural Network as well as its parameters and training method and procedure will\n",
        "    reside in this class.\n",
        "    Parameters\n",
        "    ---\n",
        "    size: list of number of neurons per layer\n",
        "    Examples\n",
        "    ---\n",
        "    >>> import NeuralNetwork\n",
        "    >>> nn = NeuralNetwork([2, 3, 4, 1])\n",
        "\n",
        "    This means :\n",
        "    1 input layer with 2 neurons\n",
        "    1 hidden layer with 3 neurons\n",
        "    1 hidden layer with 4 neurons\n",
        "    1 output layer with 1 neuron\n",
        "\n",
        "    '''\n",
        "\n",
        "    def __init__(self, size, seed=42):\n",
        "        '''\n",
        "        Instantiate the weights and biases of the network\n",
        "        weights and biases are attributes of the NeuralNetwork class\n",
        "        They are updated during the training\n",
        "        '''\n",
        "        self.seed = seed\n",
        "        np.random.seed(self.seed)\n",
        "        self.size = size\n",
        "        # biases are initialized randomly\n",
        "        self.biases = [np.random.rand(n, 1) for n in self.size[1:]]\n",
        "\n",
        "        \n",
        "        # initialize the weights randomly\n",
        "\n",
        "        #For the GAN\n",
        "        \n",
        "        self.Discriminator_W1 = np.random.normal(size=(784,128),scale=(1. / np.sqrt(784 / 2.)))   *0.002\n",
        "        self.Discriminator_b1 = np.zeros(128)\n",
        "\n",
        "        self.Discriminator_W2 = np.random.normal(size=(128,1),scale=(1. / np.sqrt(128 / 2.)))     *0.002\n",
        "        self.Discriminator_b2 = np.zeros(1)\n",
        "\n",
        "\n",
        "        self.Generator_W1 = np.random.normal(size=(100,128),scale=(1. / np.sqrt(100 / 2.)))   *0.002\n",
        "        self.Generator_b1 = np.zeros(128)\n",
        "\n",
        "        self.Generator_W2 = np.random.normal(size=(128,784),scale=(1. / np.sqrt(128 / 2.)))   *0.002\n",
        "        self.Generator_b2 = np.zeros(784)\n",
        "    \n",
        "        \"\"\"\n",
        "        Be careful with the dimensions of the weights\n",
        "        The dimensions of the weight of any particular layer will depend on the\n",
        "        size of the current layer and the previous layer\n",
        "        Example: Size = [16,8,4,2]\n",
        "        The weight file will be a list with 3 matrices with shapes:\n",
        "        (8,16) for weights connecting layers 1 (16) and 2(8)\n",
        "        (4,8) for weights connecting layers 2 (8) and 4(4)\n",
        "        (2,4) for weights connecting layers 3 (4) and 4(2)\n",
        "        Each matrix will be initialized with random values\n",
        "        \"\"\"\n",
        "        #self.weights\n",
        "\n",
        "        # x-1 is the number of weight matrices\n",
        "        # He initialization in which we generate random values from normal dist.\n",
        "        # and multiply by sq root of 2* (1/input units)\n",
        "\n",
        "        x = len(self.size) \n",
        "        #self.weights = [(np.random.randn(self.size[i], self.size[i-1])* np.sqrt(1/self.size[i-1]) for i in range(1,x)]\n",
        "        self.weights = [np.random.randn(self.size[i], self.size[i-1]) * np.sqrt(1 / self.size[i-1]) for i in range(1, x)]\n",
        "\n",
        "\n",
        "\n",
        "    def forward(self, input):\n",
        "        '''\n",
        "        Perform a feed forward computation\n",
        "        Parameters\n",
        "        ---\n",
        "        input: data to be fed to the network with\n",
        "        shape: (input_shape, batch_size)\n",
        "        Returns\n",
        "        ---\n",
        "        a: ouptut activation (output_shape, batch_size)\n",
        "        pre_activations: list of pre-activations per layer\n",
        "        each of shape (n[l], batch_size), where n[l] is the number\n",
        "        of neuron at layer l\n",
        "        activations: list of activations per layer\n",
        "        each of shape (n[l], batch_size), where n[l] is the number\n",
        "        of neuron at layer l\n",
        "        '''\n",
        "        a = input\n",
        "        pre_activations = []\n",
        "        activations = [a]\n",
        "        # TODO\n",
        "        # what does the zip function do?\n",
        "        for w, b in zip(self.weights, self.biases):\n",
        "            z = np.dot(w, a) + b\n",
        "            a  = activation(z)\n",
        "            pre_activations.append(z)\n",
        "            activations.append(a)\n",
        "        return a, pre_activations, activations\n",
        "\n",
        "    \"\"\"\n",
        "    Resources:\n",
        "    https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/\n",
        "    https://hmkcode.github.io/ai/backpropagation-step-by-step/\n",
        "    \"\"\"\n",
        "    def compute_deltas(self, pre_activations, y_true, y_pred):\n",
        "        \"\"\"\n",
        "        Computes a list containing the values of delta for each layer using\n",
        "        a recursion\n",
        "        Parameters:\n",
        "        ---\n",
        "        pre_activations: list of of pre-activations. each corresponding to a layer\n",
        "        y_true: ground truth values of the labels\n",
        "        y_pred: prediction values of the labels\n",
        "        Returns:\n",
        "        ---\n",
        "        deltas: a list of deltas per layer\n",
        "\n",
        "        \"\"\"\n",
        "\n",
        "        # initialize array to store the derivatives\n",
        "        deltas = [0] * (len(self.size) - 1)\n",
        "\n",
        "        #TODO\n",
        "        # Calculate the delta for each layer\n",
        "        # This is the first step in calculating the derivative\n",
        "        #The last layer is calculated as derivative of cost function *  derivative of sigmoid ( pre-activations of last layer )\n",
        "        deltas[-1] = cost_function_prime(y_true, y_pred) * activation(pre-activations[-1], derivative = True)\n",
        "\n",
        "        #TODO\n",
        "        # Recursively calculate delta for each layer from the previous layer\n",
        "        for l in range(len(deltas) - 2, -1, -1):\n",
        "            deltas[l] = np.dot(self.weights[l+1].transpose(), deltas[l+1]) * activation(pre_activation[l], derivative = True)\n",
        "            # deltas of layer l depend on the weights of layer l and l+1 and on the sigmoid derivative of the pre-activations of layer l\n",
        "            # Note that we use a dot product when multipying the weights and the deltas\n",
        "            # Check their shapes to ensure that their shapes conform to the requiremnts (You may need to transpose some of the matrices)\n",
        "            # The final shape of deltas of layer l must be the same as that of the activations of layer l\n",
        "            # Check if this is true\n",
        "            # delta[l] =\n",
        "        return deltas\n",
        "\n",
        "    \n",
        "\n",
        "    def backpropagate(self, deltas, pre_activations, activations):\n",
        "        \"\"\"\n",
        "        Applies back-propagation and computes the gradient of the loss\n",
        "        w.r.t the weights and biases of the network\n",
        "        Parameters:\n",
        "        ---\n",
        "        deltas: list of deltas computed by compute_deltas\n",
        "        pre_activations: a list of pre-activations per layer\n",
        "        activations: a list of activations per layer\n",
        "        Returns:\n",
        "        ---\n",
        "        dW: list of gradients w.r.t. the weight matrices of the network\n",
        "        db: list of gradients w.r.t. the biases (vectors) of the network\n",
        "\n",
        "        \"\"\"\n",
        "        dW = []\n",
        "        db = []\n",
        "        deltas = [0] + deltas\n",
        "        for l in range(1, len(self.size)):\n",
        "            # TODO\n",
        "            # Compute the derivatives of the weights and the biases from the delta values calculated earlier\n",
        "            # dW_temp depends on the activations of layer l-1 and the deltas of layer l\n",
        "            # dB_temp depends only on the deltas of layer l\n",
        "            # Again be careful of the dimensions and ensure that the dW matrix has the same shape as W\n",
        "            # dW =\n",
        "            # dB =\n",
        "            dW_temp = np.dot(deltas[l], activations[l-1].transpose())\n",
        "            dB_temp = deltas[l]\n",
        "            dW.append(dW_temp)\n",
        "            db.append(np.expand_dims(db_temp.mean(axis=1), 1))\n",
        "        return dW, db\n",
        "\n",
        "    def plot_loss(self,epochs,train,test):\n",
        "        \"\"\"\n",
        "        Plots the loss function of the train test data measured every epoch\n",
        "        Parameters:\n",
        "        ---\n",
        "        epochs: number of epochs for training\n",
        "        train: list of losses on the train set measured every epoch\n",
        "        test: list of losses on the test set measured every epoch\n",
        "        \"\"\"\n",
        "\n",
        "        plt.subplot(211)\n",
        "        plt.title('Training Cost (loss)')\n",
        "        plt.plot(range(epochs),train)\n",
        "\n",
        "        plt.subplot(212)\n",
        "        plt.title('Test Cost (loss)')\n",
        "        plt.plot(range(epochs),test)\n",
        "\n",
        "        plt.subplots_adjust(hspace=0.5)\n",
        "        plt.show()\n",
        "\n",
        "    def train(self, X, y, batch_size, epochs, lr, beta_1, beta_2, eps, print_every=10, plot_every=None):\n",
        "        \"\"\"\n",
        "        Trains the network using the gradients computed by back-propagation\n",
        "        Splits the data in train and validation splits\n",
        "        Processes the training data by batches and trains the network using batch gradient descent\n",
        "        Parameters:\n",
        "        ---\n",
        "        X: input data\n",
        "        y: input labels\n",
        "        batch_size: number of data points to process in each batch\n",
        "        epochs: number of epochs for the training\n",
        "        learning_rate: value of the learning rate\n",
        "        validation_split: percentage of the data for validation\n",
        "        print_every: the number of epochs by which the network activations the loss and accuracy metrics for train and validations splits\n",
        "        plot_every: the number of epochs by which the network plots the decision boundary\n",
        "\n",
        "        Returns:\n",
        "        ---\n",
        "        history: dictionary of train and validation metrics per epoch\n",
        "            train_acc: train accuracy\n",
        "            test_acc: validation accuracy\n",
        "            train_loss: train loss\n",
        "            test_loss: validation loss\n",
        "        This history is used to plot the performance of the model\n",
        "        \"\"\"\n",
        "        history_train_losses = []\n",
        "        history_train_accuracies = []\n",
        "        history_test_losses = []\n",
        "        history_test_accuracies = []\n",
        "\n",
        "        # TODO\n",
        "        # Read about the train_test_split function\n",
        "        \"\"\"\n",
        "        \n",
        "        x_train, x_test, y_train, y_test = train_test_split(X.T, y.T, test_size=0.2, )\n",
        "        x_train, x_test, y_train, y_test = x_train.T, x_test.T, y_train.T, y_test.T\n",
        "\n",
        "        epoch_iterator = range(epochs)\n",
        "\n",
        "        for e in epoch_iterator:\n",
        "            if x_train.shape[1] % batch_size == 0:\n",
        "                n_batches = int(x_train.shape[1] / batch_size)\n",
        "            else:\n",
        "                n_batches = int(x_train.shape[1] / batch_size ) - 1\n",
        "\n",
        "            x_train, y_train = shuffle(x_train.T, y_train.T)\n",
        "            x_train, y_train = x_train.T, y_train.T\n",
        "\n",
        "            batches_x = [x_train[:, batch_size*i:batch_size*(i+1)] for i in range(0, n_batches)]\n",
        "            batches_y = [y_train[:, batch_size*i:batch_size*(i+1)] for i in range(0, n_batches)]\n",
        "            \n",
        "\n",
        "            train_losses = []\n",
        "            train_accuracies = []\n",
        "\n",
        "            test_losses = []\n",
        "            test_accuracies = []\n",
        "\n",
        "            dw_per_epoch = [np.zeros(w.shape) for w in self.weights]\n",
        "            db_per_epoch = [np.zeros(b.shape) for b in self.biases]\n",
        "\n",
        "            for batch_x, batch_y in zip(batches_x, batches_y):\n",
        "                batch_y_pred, pre_activations, activations = self.forward(batch_x)\n",
        "                deltas = self.compute_deltas(pre_activations, batch_y, batch_y_pred)\n",
        "                dW, db = self.backpropagate(deltas, pre_activations, activations)\n",
        "                for i, (dw_i, db_i) in enumerate(zip(dW, db)):\n",
        "                    dw_per_epoch[i] += dw_i / batch_size\n",
        "                    db_per_epoch[i] += db_i / batch_size\n",
        "\n",
        "                batch_y_train_pred = self.predict(batch_x)\n",
        "\n",
        "                train_loss = cost_function(batch_y, batch_y_train_pred)\n",
        "                train_losses.append(train_loss)\n",
        "                train_accuracy = accuracy_score(batch_y.T, batch_y_train_pred.T)\n",
        "                train_accuracies.append(train_accuracy)\n",
        "\n",
        "                batch_y_test_pred = self.predict(x_test)\n",
        "\n",
        "                test_loss = cost_function(y_test, batch_y_test_pred)\n",
        "                test_losses.append(test_loss)\n",
        "                test_accuracy = accuracy_score(y_test.T, batch_y_test_pred.T)\n",
        "                test_accuracies.append(test_accuracy)\n",
        "\n",
        "\n",
        "            # weight update\n",
        "\n",
        "            # TODO\n",
        "            # What does the enumerate function do?\n",
        "            for i, (dw_epoch, db_epoch) in enumerate(zip(dw_per_epoch, db_per_epoch)):\n",
        "                \n",
        "                \n",
        "                # Update the weights using the backpropagation algorithm implemented earlier\n",
        "                # W = W - learning_rate * derivatives (dW)\n",
        "                # b = b - learning_rate * derivatives (db)\n",
        "                self.weights[i]  = self.weights[i] - learning_rate * dw_epoch\n",
        "                self.biases[i] = self.biases[i] - learning_rate * db_epoch\n",
        "\n",
        "            history_train_losses.append(np.mean(train_losses))\n",
        "            history_train_accuracies.append(np.mean(train_accuracies))\n",
        "\n",
        "            history_test_losses.append(np.mean(test_losses))\n",
        "            history_test_accuracies.append(np.mean(test_accuracies))\n",
        "\n",
        "\n",
        "            if e % print_every == 0:\n",
        "                print('Epoch {} / {} | train loss: {} | train accuracy: {} | val loss : {} | val accuracy : {} '.format(\n",
        "                    e, epochs, np.round(np.mean(train_losses), 3), np.round(np.mean(train_accuracies), 3),\n",
        "                    np.round(np.mean(test_losses), 3),  np.round(np.mean(test_accuracies), 3)))\n",
        "\n",
        "        self.plot_loss(epochs,train_loss,test_loss)\n",
        "\n",
        "        history = {'epochs': epochs,\n",
        "                   'train_loss': history_train_losses,\n",
        "                   'train_acc': history_train_accuracies,\n",
        "                   'test_loss': history_test_losses,\n",
        "                   'test_acc': history_test_accuracies\n",
        "                   }\n",
        "        return history\n",
        "        \"\"\"\n",
        "        \n",
        "\n",
        "\n",
        "        Discriminator_W1 = self.Discriminator_W1\n",
        "        Discriminator_b1 = self.Discriminator_b1\n",
        "\n",
        "        Discriminator_W2 = self.Discriminator_W2\n",
        "        Discriminator_b2 = self.Discriminator_b2\n",
        "\n",
        "\n",
        "        Generator_W1 = self.Generator_W1\n",
        "        Generator_b1 = self.Generator_b1\n",
        "\n",
        "        Generator_W2 = self.Generator_W2 \n",
        "        Generator_b2 = self.Generator_b2\n",
        "\n",
        "\n",
        "        \n",
        "\n",
        "        for iter in range(epochs):\n",
        "\n",
        "            num = np.random.randint(59999)\n",
        "            current_image = np.expand_dims(images[num],axis=0)\n",
        "\n",
        "    #Generating the fake data\n",
        "\n",
        "            Z = np.random.uniform(0, 1., size=[1, 100])\n",
        "            Generator_l1 = Z.dot(Generator_W1) + Generator_b1\n",
        "            Generator_l1A = activation(Generator_l1)\n",
        "            Generator_l2 = Generator_l1A.dot(Generator_W2) + Generator_b2\n",
        "    \n",
        "            cfd = activation(Generator_l2)\n",
        "\n",
        "    #Forward propagation for real data\n",
        "\n",
        "            Discriminator_l1_r = current_image.dot(Discriminator_W1) + Discriminator_b1\n",
        "            Discriminator_l1_rA = activation(Discriminator_l1_r)\n",
        "            Discriminator_l2_r = Discriminator_l1_rA.dot(Discriminator_W2) + Discriminator_b2\n",
        "            Discriminator_l2_rA = activation(Discriminator_l2_r)\n",
        "\n",
        "    #Forward propagation for fake data\n",
        "            Discriminator_l1_f = cfd.dot(Discriminator_W1) + Discriminator_b1\n",
        "            Discriminator_l1_fA = activation(Discriminator_l1_f)\n",
        "            Discriminator_l2_f = Discriminator_l1_fA.dot(Discriminator_W2) + Discriminator_b2\n",
        "            Discriminator_l2_fA = activation(Discriminator_l2_f)\n",
        "\n",
        "    #Now we calculate the cost for the discriminator\n",
        "\n",
        "            Discriminator_cost = -np.log(Discriminator_l2_rA) + np.log(1.0- Discriminator_l2_fA)\n",
        "\n",
        "\n",
        "    #Back propagation for discriminator\n",
        "\n",
        "            grad_f_w2 =  (Discriminator_l1_fA).T.dot((1/(1.0- Discriminator_l2_fA)) * (d_activation(Discriminator_l2_f))) \n",
        "            grad_f_b2 = (1/(1.0- Discriminator_l2_fA)) * (d_activation(Discriminator_l2_f))\n",
        "\n",
        "            grad_f_w1 = cfd.T.dot((((1/(1.0- Discriminator_l2_fA))* (d_activation(Discriminator_l2_f))).dot(Discriminator_W2.T)) * (d_activation(Discriminator_l1_f))) \n",
        "            grad_f_b1 = (((1/(1.0- Discriminator_l2_fA))* (d_activation(Discriminator_l2_f))).dot(Discriminator_W2.T)) * (d_activation(Discriminator_l1_f))\n",
        "\n",
        " \n",
        "            grad_r_w2 = (Discriminator_l1_rA).T.dot((- 1/Discriminator_l2_rA) * (d_activation(Discriminator_l2_r))) \n",
        "            grad_r_b2 = (- 1/Discriminator_l2_rA)* (d_activation(Discriminator_l2_r))\n",
        "\n",
        "            grad_r_w1 = current_image.T.dot((((- 1/Discriminator_l2_rA) * (d_activation(Discriminator_l2_r))).dot(Discriminator_W2.T)) * (d_activation(Discriminator_l1_r))) \n",
        "            grad_r_b1 = (((- 1/Discriminator_l2_rA) * (d_activation(Discriminator_l2_r))).dot(Discriminator_W2.T))* (d_activation(Discriminator_l1_r))\n",
        "\n",
        "            grad_w1 =grad_f_w1 + grad_r_w1\n",
        "            grad_b1 =grad_f_b1 + grad_r_b1\n",
        "    \n",
        "            grad_w2 =grad_f_w2 + grad_r_w2\n",
        "            grad_b2 =grad_f_b2 + grad_r_b2\n",
        "\n",
        "    # ---- Update Gradient ----\n",
        "\n",
        "            v1,m1 = 0,0\n",
        "            v2,m2 = 0,0\n",
        "            v3,m3 = 0,0\n",
        "            v4,m4 = 0,0\n",
        "            m1 = beta_1 * m1 + (1 - beta_1) * grad_w1\n",
        "            v1 = beta_2 * v1 + (1 - beta_2) * grad_w1 ** 2\n",
        "\n",
        "            m2 = beta_1 * m2 + (1 - beta_1) * grad_b1\n",
        "            v2 = beta_2 * v2 + (1 - beta_2) * grad_b1 ** 2\n",
        "\n",
        "            m3 = beta_1 * m3 + (1 - beta_1) * grad_w2\n",
        "            v3 = beta_2 * v3 + (1 - beta_2) * grad_w2 ** 2\n",
        "\n",
        "            m4 = beta_1 * m4 + (1 - beta_1) * grad_b2\n",
        "            v4 = beta_2 * v4 + (1 - beta_2) * grad_b2 ** 2\n",
        "\n",
        "            Discriminator_W1 = Discriminator_W1 - (lr / (np.sqrt(v1 /(1-beta_2) ) + eps)) * (m1/(1-beta_1))\n",
        "            Discriminator_b1 = Discriminator_b1 - (lr / (np.sqrt(v2 /(1-beta_2) ) + eps)) * (m2/(1-beta_1))\n",
        "    \n",
        "            Discriminator_W2 = Discriminator_W2 - (lr / (np.sqrt(v3 /(1-beta_2) ) + eps)) * (m3/(1-beta_1))\n",
        "            Discriminator_b2 = Discriminator_b2 - (lr / (np.sqrt(v4 /(1-beta_2) ) + eps)) * (m4/(1-beta_1))\n",
        "\n",
        "\n",
        "    #Forward propagation for generator\n",
        "\n",
        "            Z = np.random.uniform(-1., 1., size=[1, 100])\n",
        "            Generator_l1 = Z.dot(Generator_W1) + Generator_b1\n",
        "            Generator_l1A = activation(Generator_l1)\n",
        "            Generator_l2 = Generator_l1A.dot(Generator_W2) + Generator_b2\n",
        "  \n",
        "            cfd = activation(Generator_l2)\n",
        "\n",
        "            Discriminator_l1 = cfd.dot(Discriminator_W1) + Discriminator_b1\n",
        "            Discriminator_l1_A = activation(Discriminator_l1)\n",
        "            Discriminator_l2 = Discriminator_l1_A.dot(Discriminator_W2) + Discriminator_b2\n",
        "            Discriminator_l2_A = activation(Discriminator_l2)\n",
        "\n",
        "     #Calculation the cost for generator\n",
        "\n",
        "            Generator_cost = -np.log(Discriminator_l2_A)\n",
        "\n",
        "\n",
        "    #Back propagation for generator\n",
        "\n",
        "            g1 = ((-1/Discriminator_l2_A) * d_activation(Discriminator_l2).dot(Discriminator_W2.T) * (d_activation(Discriminator_l1))).dot(Discriminator_W1.T)\n",
        "            grad_Generator_w2 = (Generator_l1A).T.dot(g1 * ( d_activation(Generator_l2)))\n",
        "            grad_Generator_b2 = (g1 * ( d_activation(Generator_l2)))\n",
        "\n",
        "            grad_Generator_w1 = Z.T.dot(( (g1 *  d_activation(Generator_l2)).dot(Generator_W2.T)) * d_activation(Generator_l1))\n",
        "            grad_Generator_b1 = ( (g1 *  d_activation(Generator_l2)).dot(Generator_W2.T))* (d_activation(Generator_l1))\n",
        "\n",
        "            v5,m5 = 0,0\n",
        "            v6,m6 = 0,0\n",
        "            v7,m7 = 0,0\n",
        "            v8,m8 = 0,0\n",
        "            m5 = beta_1 * m5 + (1 - beta_1) * grad_Generator_w1\n",
        "            v5 = beta_2 * v5 + (1 - beta_2) * grad_Generator_w1 ** 2\n",
        "\n",
        "            m6 = beta_1 * m6 + (1 - beta_1) * grad_Generator_b1\n",
        "            v6 = beta_2 * v6 + (1 - beta_2) * grad_Generator_b1 ** 2\n",
        "\n",
        "            m7 = beta_1 * m7 + (1 - beta_1) * grad_Generator_w2\n",
        "            v7 = beta_2 * v7 + (1 - beta_2) * grad_Generator_w2 ** 2\n",
        "\n",
        "            m8 = beta_1 * m8 + (1 - beta_1) * grad_Generator_b2\n",
        "            v8 = beta_2 * v8 + (1 - beta_2) * grad_Generator_b2 ** 2\n",
        "\n",
        "            Generator_W1 = Generator_W1 - (lr/ (np.sqrt(v5 /(1-beta_2) ) + eps)) * (m5/(1-beta_1))\n",
        "            Generator_b1 = Generator_b1 - (lr / (np.sqrt(v6 /(1-beta_2) ) + eps)) * (m6/(1-beta_1))\n",
        "    \n",
        "            Generator_W2 = Generator_W2 - (lr / (np.sqrt(v7 /(1-beta_2) ) + eps)) * (m7/(1-beta_1))\n",
        "            Generator_b2 = Generator_b2 - (lr / (np.sqrt(v8 /(1-beta_2) ) + eps)) * (m8/(1-beta_1))\n",
        "\n",
        "            if iter == 0:\n",
        "                lr = lr * 0.01\n",
        "            if iter == 40:\n",
        "                lr= lr * 0.01\n",
        "\n",
        " \n",
        "            if iter%10 == 0:\n",
        "        \n",
        "        \n",
        "                Z = np.random.uniform(0, 1., size=[16, 100]) \n",
        "\n",
        "                Generator_l1 = Z.dot(Generator_W1) + Generator_b1\n",
        "                Generator_l1A = activation(Generator_l1)\n",
        "                Generator_l2 = Generator_l1A.dot(Generator_W2) + Generator_b2\n",
        "        \n",
        "                cfd= activation(Generator_l2)\n",
        "        \n",
        "                fig = plot(cfd)\n",
        "       \n",
        "    def predict(self, a):\n",
        "        '''\n",
        "        Use the current state of the network to make predictions\n",
        "        Parameters:\n",
        "        ---\n",
        "        a: input data, shape: (input_shape, batch_size)\n",
        "        Returns:\n",
        "        ---\n",
        "        predictions: vector of output predictions\n",
        "        '''\n",
        "        for w, b in zip(self.weights, self.biases):\n",
        "            z = np.dot(w, a) + b\n",
        "            a = activation(z)\n",
        "        predictions = (a > 0.5).astype(int)\n",
        "        return predictions\n",
        "\n",
        "# Author: Ahmed BESBES\n",
        "# <ahmed.besbes@hotmail.com>\n",
        "\n"
      ],
      "execution_count": 68,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ySNs_XbgMtY1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "outputId": "57a45a0f-7343-4a4b-dcd9-8957f42fb934"
      },
      "source": [
        "gan = NeuralNetwork([784,128,686,10])\n",
        "gan.train(X_train, y_train, 100, 10,  0.0001, 0.9,0.999,0.00000001)"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 16 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PRw4d1Y7VqZI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}