notebooks/Genetic_Pseudo_Rehearsal_Demo.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Genetic_Pseudo_Rehearsal_Demo.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SO1IYJJ2fgqY"
      },
      "source": [
        "<center> <h1>Pseudo Rehearsal using non photo-realistic images </center>\n",
        "\n",
        "This work is an implementation of the technique discussed in the paper titled <b>Pseudo rehearsal using non photo-realistic images.</b> The full paper can be found at this <a href=\"https://ieeexplore.ieee.org/document/9412827\">link</a> and the arxiv preprint in this <a href=\"https://arxiv.org/abs/2004.13414\">link.</a>\n",
        "\n",
        "<h3>Introduction:</h3>\n",
        "1. In this work, we try to establish that neural networks can be pseudo rehearsed on synthetic images that are not photo-realistic.<br>\n",
        "2. Instead of using generative networks to generate photo-realistic synthetic data, in this work, we pseudo rehearse a neural network on non photo-realistic data generated using <b>Genetic Algorithms</b>.\n",
        "\n",
        "<h3>Experiment</h3>\n",
        "One simple experiment reported in the paper is replicated to keep the notebook short and within reach of computational resources available on google colab. <br>\n",
        "1. In this experiment, we first train a neural network on MNIST Fashion dataset. <br>\n",
        "2. Then, Genetic Algorithms is used to create synthetic data for Fashion dataset.<br>\n",
        "3. We then train the same neural network on MNIST Digits dataset while pseudo rehearsing it on the synthetic data for MNIST Fashion that we just created using Genetic Algorithms.\n",
        "\n",
        "The retention and learning behavior of the neural network is then observed.\n",
        "\n",
        "<b>NOTE:</b> If you are using Google colab to run the notebook, please ensure that there is atleast 25GB of allocated RAM.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oemvCYwWH5sL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e42cb8be-ec64-4c9f-cc69-239c89b6855b"
      },
      "source": [
        "# This code was written for Tensorflow 1. \n",
        "# So please ensure that google colab uses Tensorflow 1 while executing the codes.\n",
        "# Running this cell ensures that Tensorflow 1 is used.\n",
        "\n",
        "%tensorflow_version 1.x"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "TensorFlow 1.x selected.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wp75nxcIVUxe"
      },
      "source": [
        "## Loading MNIST Fashion dataset\n",
        "\n",
        "First, we load MNIST Fashion dataset. We reshape the dataset such that all the image samples are now flattened."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p_2Fzqw8WcG2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4c2019ec-02cc-40e8-da95-ddb637ddd8c3"
      },
      "source": [
        "import keras\n",
        "from keras.datasets import fashion_mnist\n",
        "import numpy as np\n",
        "\n",
        "(x_train_h, y_train_h), (x_test_h, y_test_h) = fashion_mnist.load_data()\n",
        "\n",
        "x_train_h = x_train_h/255\n",
        "x_test_h = x_test_h/255\n",
        "\n",
        "y_train_h = np.copy(y_train_h)\n",
        "y_test_h = np.copy(y_test_h)\n",
        "\n",
        "x_train_h = np.reshape(x_train_h,(60000,28,28,1))\n",
        "x_test_h = np.reshape(x_test_h,(10000,28,28,1))\n",
        "\n",
        "pre_y_train_h = y_train_h\n",
        "pre_y_test_h = y_test_h\n",
        "\n",
        "y_test_h = keras.utils.to_categorical(y_test_h, 20)\n",
        "y_train_h = keras.utils.to_categorical(y_train_h, 20)\n",
        "\n",
        "x_train_h = np.reshape(x_train_h,(60000,784))\n",
        "x_test_h = np.reshape(x_test_h,(10000,784))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using TensorFlow backend.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ofK7fbA1VX-t"
      },
      "source": [
        "## Initialize a neural network\n",
        "\n",
        "For this tutorial, let us initialize a simple, fully connected neural network.\n",
        "\n",
        " Please note that the proposed technique is scalable to any type of classification network like CNN.\n",
        "\n",
        "Feel free to plug in any other architecture of your choice. However, make sure that the parameters of the genetic algorithm are adjusted accordingly."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MeFOiJKbW3wf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5fda578c-6b15-4329-9c57-ae1ae56cfb11"
      },
      "source": [
        "from keras.models import Sequential\n",
        "from keras.layers import Flatten, Dense, Activation\n",
        "\n",
        "model = Sequential()\n",
        "\n",
        "model.add(Dense(512))\n",
        "model.add(Activation('relu'))\n",
        "model.add(Dense(256))\n",
        "model.add(Activation('relu'))\n",
        "model.add(Dense(20))\n",
        "model.add(Activation('softmax'))\n",
        "model.compile(loss=keras.losses.categorical_crossentropy,\n",
        "              optimizer=keras.optimizers.Adadelta(),\n",
        "              metrics=['accuracy'])"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From /tensorflow-1.15.2/python3.7/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "If using Keras pass *_constraint arguments to layers.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C3yuJOERNzEP"
      },
      "source": [
        "## Train the network on MNIST Fashion\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YxRipsPDW9rW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6edb5e40-045c-41ea-da6c-8afd9bf17bb2"
      },
      "source": [
        "history_original = model.fit(x_train_h,y_train_h,verbose=1,epochs=5,batch_size=100)\n",
        "score = model.evaluate(x_test_h,y_test_h,verbose=1)\n",
        "print(\"\\nAccuracy of the model on Fashion dataset: \",score[1]*100,\"%\")"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From /tensorflow-1.15.2/python3.7/keras/backend/tensorflow_backend.py:422: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n",
            "\n",
            "Epoch 1/5\n",
            "60000/60000 [==============================] - 7s 111us/step - loss: 0.5533 - accuracy: 0.7987\n",
            "Epoch 2/5\n",
            "60000/60000 [==============================] - 7s 109us/step - loss: 0.3807 - accuracy: 0.8586\n",
            "Epoch 3/5\n",
            "60000/60000 [==============================] - 7s 109us/step - loss: 0.3379 - accuracy: 0.8737\n",
            "Epoch 4/5\n",
            "60000/60000 [==============================] - 7s 109us/step - loss: 0.3096 - accuracy: 0.8847\n",
            "Epoch 5/5\n",
            "60000/60000 [==============================] - 6s 108us/step - loss: 0.2888 - accuracy: 0.8914\n",
            "10000/10000 [==============================] - 1s 68us/step\n",
            "\n",
            "Accuracy of the model on Fashion dataset:  87.6200020313263 %\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L3NJReA6VZ3p"
      },
      "source": [
        "# Creating synthetic data for MNIST Fashion dataset from our model.\n",
        "\n",
        "In this work, instead of using a separate neural structure to generate synthetic data, we use the neural network itself to generate synthetic data. We do this using Genetic Algorithms. To get a better understanding of the technique, please refer to the <a href=\"https://ieeexplore.ieee.org/document/9412827\">paper</a>."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aYgPp5v1ORt3"
      },
      "source": [
        "## Setting the parameters of the Genetic Algorithm\n",
        "\n",
        "These parameters are responsible for altering the rate of convergence of the Genetic Algorithm. \n",
        "\n",
        "Play around with these parameters to see changes in increase or decrease in the rate of convergence of the algorithm.\n",
        "\n",
        "You will also notice that rate of convergence is not the same for all classes, so you can try to set different parameters for different classes.\n",
        "\n",
        "Note: If you plugged in your own network or a different dataset in the previous step, then change the parameters accordingly."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1u4ous2gPkKP"
      },
      "source": [
        "population_size=16\n",
        "NUMBER_OF_CULTURES = 30\n",
        "NUMBER_OF_GENERATIONS = 100\n",
        "MUTATION_PROBABILITY = 0.1\n",
        "MUTATION_TYPE = \"+\"\n",
        "\n",
        "#Three times of mutations are possible. +,-,*."
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-0iANfH_Nw4_"
      },
      "source": [
        "## Declaring functions required for Genetic Algorithm"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z6j3E7uTN3xN"
      },
      "source": [
        "from scipy.spatial import distance\n",
        "from sklearn.mixture import GaussianMixture\n",
        "from heapq import nlargest\n",
        "import random\n",
        "\n",
        "def crossover(first_gene,second_gene,index):\n",
        "  temp = np.copy(first_gene[index:])\n",
        "  first_gene[index:] = second_gene[index:]\n",
        "  second_gene[index:]=temp\n",
        "\n",
        "def generate_labels(data,model,number_of_classes):\n",
        "  '''\n",
        "  . \\n\\n\n",
        "  AUTHOR:\n",
        "  Suri Bhasker Sri Harsha\n",
        "\n",
        "  AIM:\n",
        "  The function assigns labels to the given dataset with the given model as the reference.\n",
        "  The function returns a list with labels in two formats. The first format is the one-hot encoding\n",
        "  format and the second format is the binary format of labels.\n",
        "\n",
        "  ARGUMENTS:\n",
        "  data: The dataset for which you want to generate labels\n",
        "  model: The model that will be used for the label generation\n",
        "  number_of_classes: Number of classes in the dataset\n",
        "\n",
        "  RETURNS:\n",
        "  [labels, pre_labels]\n",
        "  '''\n",
        "\n",
        "  labels = model.predict_classes(data,verbose=1)\n",
        "  pre_labels = labels\n",
        "  labels = keras.utils.to_categorical(labels,number_of_classes)\n",
        "\n",
        "  return [labels,pre_labels]\n",
        "def agreement_score(model1_predictions, model2_predictions):\n",
        "\n",
        "  '''\n",
        "  Returns the degree of agreement between predictions of two models\n",
        "\n",
        "  INPUT ARGUMENTS\n",
        "  model1_predictions: Preditions of the model 1 on a test dataset\n",
        "  model2_predictions: Preditions of the model 2 on a test dataset\n",
        "\n",
        "  OUTPUT:\n",
        "  Returns a list of two elements where the first elements is the\n",
        "  \"Agreement score\" between the two lists and the second element\n",
        "  is the list of indices where both the models have agreed upon.\n",
        "  '''\n",
        "\n",
        "  if len(model1_predictions) != len(model2_predictions):\n",
        "    print(\"Length of given lists donot match\")\n",
        "    return 0\n",
        "\n",
        "  correct_count = 0\n",
        "  agreement_indices = []\n",
        "\n",
        "  for i in range(len(model1_predictions)):\n",
        "    if model1_predictions[i] == model2_predictions[i]:\n",
        "      correct_count += 1\n",
        "      agreement_indices.append(i)\n",
        "\n",
        "  agreement_score = (correct_count/len(model1_predictions))*100\n",
        "\n",
        "  return [agreement_score, agreement_indices]\n",
        "\n",
        "\n",
        "def Enrichment(data,labels,model,NUMBER_OF_CENTERS,NUMBER_OF_CLASSES, NUMBER_OF_SAMPLES, verbose=0):\n",
        "    '''\n",
        "    Enriches the given data by fitting a Gaussian Mixture model with\n",
        "    NUMBER_OF_CENTERS and NUMBER_OF_SAMPLES\n",
        "    '''\n",
        "    if verbose == 1:\n",
        "        print(\"Creating the Gaussian mixture model ...\")\n",
        "    gaussian = GaussianMixture(n_components = NUMBER_OF_CENTERS)\n",
        "\n",
        "    if verbose == 1:\n",
        "        print(\"Created the model ...\")\n",
        "\n",
        "    if verbose == 1:\n",
        "        print(\"Fitting the data to the GMM ...\")\n",
        "    gaussian.fit(X=data)\n",
        "\n",
        "    if verbose == 1:\n",
        "        print(\"Generating synthetic samples ....\")\n",
        "    synthetic = gaussian.sample(n_samples=NUMBER_OF_SAMPLES)\n",
        "\n",
        "    synthetic_data = synthetic[0]\n",
        "\n",
        "    if verbose == 1:\n",
        "        print(\"Generating labels ...\")\n",
        "    labels = model.predict_classes(synthetic_data,verbose=1)\n",
        "    pre_labels = labels\n",
        "    labels = keras.utils.to_categorical(labels,NUMBER_OF_CLASSES)\n",
        "\n",
        "    return [synthetic_data, labels, pre_labels]\n"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vD2NGdR3XZRr"
      },
      "source": [
        "from heapq import nlargest\n",
        "import random\n",
        "\n",
        "pseudo_x_train_2400 = np.zeros((0,784))\n",
        "\n",
        "POINTS_GATHERED = []\n",
        "ideal_points = []\n",
        "\n",
        "for class_number in range(10):\n",
        "  POINTS_COUNTER=0\n",
        "  print(\"Class number: \", class_number)\n",
        "\n",
        "  for p in range(NUMBER_OF_CULTURES): \n",
        "\n",
        "    # CREATING THE INITIAL POPULATION \n",
        "    '''Here, the initial population is made of \"zeros\". Try different initial populations to see \n",
        "    how the evolution changes.'''\n",
        "    current_generation=[]\n",
        "    for i in range(population_size):\n",
        "      current_generation.append(np.zeros((784)))\n",
        "    \n",
        "    best = 0\n",
        "    best_list=[]\n",
        "\n",
        "    '''The stopping criteria for the genetic algorithm can be set here.\n",
        "    Currently, the algorithm runs till a fitness of 99% is reached by any organism,\n",
        "    alternatively, it could be restricted based on the maximum number of generations for which \n",
        "    the algorithm can run.\n",
        "    '''\n",
        "    while best*100 < 99:\n",
        "    # for generation_number in range(NUMBER_OF_GENERATIONS):\n",
        "\n",
        "      current_generation_fitness=[]\n",
        "      \n",
        "      '''Finding the fitness of each organism in the current population'''\n",
        "      for i in range(population_size):\n",
        "\n",
        "        test_point = np.reshape(current_generation[i],(1,784))\n",
        "\n",
        "        fitness_score = model.predict(test_point)[0][class_number]\n",
        "        class_prediction= model.predict_classes(test_point)\n",
        "        current_generation_fitness.append(fitness_score)\n",
        "\n",
        "      if max(current_generation_fitness) >= best:\n",
        "        best = max(current_generation_fitness)\n",
        "      \n",
        "      print(\"Best: \",best*100, \" Culture number: \",p,\" Class number: \",class_number)\n",
        "      \n",
        "\n",
        "      '''Finding the indices of the fittest 25% organisms'''\n",
        "      fittest_four_model_indices = nlargest(int(population_size/4), range(len(current_generation_fitness)), current_generation_fitness.__getitem__)\n",
        "  \n",
        "      # VERIFIED\n",
        "      temp_list=[]\n",
        "      for temp in range(int(population_size/4)):\n",
        "        temp_list.append(np.copy(current_generation[fittest_four_model_indices[temp]]))\n",
        "      \n",
        "\n",
        "      # VERIFIED\n",
        "      for temp in range(int(population_size/4)):\n",
        "        current_generation[temp] = np.copy(temp_list[temp])\n",
        "     \n",
        "  \n",
        "      '''Performing mutation operations on the current generation to create the next generation.'''\n",
        "      # VERIFIED\n",
        "      for temp in range((int(population_size/4)),(int(population_size/2))):\n",
        "        current_generation[temp] = np.copy(current_generation[temp-(int(population_size/4))])     \n",
        "  \n",
        "      # VERIFIED\n",
        "      for i in range((int(population_size/4)),(int(population_size/2))):\n",
        "        point_mutation=np.random.choice([0,abs(np.random.normal(0,1,[1]))],size=current_generation[i].shape, p=[(1-MUTATION_PROBABILITY),MUTATION_PROBABILITY])\n",
        "\n",
        "        if MUTATION_TYPE == \"*\":\n",
        "          choice=random.choice([\"+\",\"-\",\"*\"])\n",
        "          if choice== \"-\":\n",
        "            current_generation[i] = current_generation[i] - point_mutation\n",
        "          elif choice==\"+\":\n",
        "            current_generation[i] = current_generation[i] + point_mutation\n",
        "        elif MUTATION_TYPE == \"+\":\n",
        "          current_generation[i] = current_generation[i] + point_mutation\n",
        "        else:\n",
        "          current_generation[i] = current_generation[i] - point_mutation\n",
        "      \n",
        "      \n",
        "      '''Performing crossover operations on the current generation to create the next generation'''\n",
        "      # VERIFIED\n",
        "      for temp in range((int(population_size/2)),(int(population_size*0.75))):\n",
        "        current_generation[temp] = np.copy(current_generation[temp-(int(population_size/2))])\n",
        "     \n",
        "  \n",
        "      # VERIFIED\n",
        "      for temp in range((int(population_size/2)),(int(population_size*0.75))):\n",
        "        if temp%2 == 0:\n",
        "          crossover(current_generation[temp],current_generation[temp+1],int((current_generation[temp].shape)[0]/2))\n",
        "  \n",
        "      '''Performing mutated-crossover of the current generation to create the next generation'''\n",
        "      # VERIFIED\n",
        "      for temp in range((int(population_size*0.75)),population_size):\n",
        "        current_generation[temp] = np.copy(current_generation[temp-(int(population_size/2))])\n",
        "  \n",
        "      # VERIFIED\n",
        "      for temp in range((int(population_size*0.75)),population_size):\n",
        "        if temp%2 == 0:\n",
        "          crossover(current_generation[temp],current_generation[temp+1],int((current_generation[temp].shape)[0]/2))\n",
        "    for k in range(len(current_generation)):\n",
        "      pseudo_x_train_2400 = np.vstack((pseudo_x_train_2400,np.reshape(current_generation[k],(1,784))))\n",
        "    \n",
        "print(\"Generated data: \",pseudo_x_train_2400.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "26stzzJoXfUH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "00585257-d4ba-478e-a9df-9c38077fa900"
      },
      "source": [
        "'''Since the synthetic data generated using Genetic Algorithms has no labels, we use our model to \n",
        "generate labels for them.'''\n",
        "\n",
        "from sklearn.utils import class_weight\n",
        "\n",
        "print(pseudo_x_train_2400.shape)\n",
        "\n",
        "pseudo_y_train_2400 = model.predict_classes(pseudo_x_train_2400)\n",
        "\n",
        "pre_pseudo_y_train_2400 = pseudo_y_train_2400\n",
        "pseudo_y_train_2400 = keras.utils.to_categorical(pseudo_y_train_2400, 10)\n",
        "print(\"Synthetic data shape: \",pseudo_x_train_2400.shape)\n",
        "print(\"Synthetic labels shape: \",pseudo_y_train_2400.shape)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4800, 784)\n",
            "Synthetic data shape:  (4800, 784)\n",
            "Synthetic labels shape:  (4800, 10)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d8aj3ef3acdJ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "4d02b54a-e591-49f4-a288-46c67a9e9791"
      },
      "source": [
        "# SANITY CHECK\n",
        "'''Un-comment this to see the coverage for each class.'''\n",
        "\n",
        "# count = [0,0,0,0,0,0,0,0,0,0]\n",
        "# for i in range(pseudo_x_train_2400.shape[0]):\n",
        "#   count[pre_pseudo_y_train_2400[i]]+=1\n",
        "\n",
        "# print(count)\n",
        "# print(sum(count))"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Un-comment this to see the coverage for each class.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8SOVMbSZM17H"
      },
      "source": [
        "## Enriching the genetic data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RNu55b1BOoo9"
      },
      "source": [
        "### Enrichment step 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BjYiEZgjT36d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "620709ad-ae85-4c78-e1d6-e19cd841dd16"
      },
      "source": [
        "help(Enrichment)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on function Enrichment in module __main__:\n",
            "\n",
            "Enrichment(data, labels, model, NUMBER_OF_CENTERS, NUMBER_OF_CLASSES, NUMBER_OF_SAMPLES, verbose=0)\n",
            "    Enriches the given data by fitting a Gaussian Mixture model with\n",
            "    NUMBER_OF_CENTERS and NUMBER_OF_SAMPLES\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C3yWYk_FQuki",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1a1aa9ec-58d3-4d7b-af36-b29d0e7ca953"
      },
      "source": [
        "NUMBER_OF_SAMPLES = int(pseudo_x_train_2400.shape[0])*2\n",
        "temp = Enrichment(pseudo_x_train_2400,pseudo_y_train_2400,model,10,10,NUMBER_OF_SAMPLES=NUMBER_OF_SAMPLES)\n",
        "\n",
        "synthetic_data = temp[0]\n",
        "synthetic_labels = temp[1]\n",
        "\n",
        "print(\"Training data shape: \",synthetic_data.shape)\n",
        "print(\"Training labels shape: \",synthetic_labels.shape)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "9600/9600 [==============================] - 0s 45us/step\n",
            "Training data shape:  (9600, 784)\n",
            "Training labels shape:  (9600, 10)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SQ1SyAsDFRez",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "cc9570c6-c3b5-413a-e046-5d8eb98dc1f4"
      },
      "source": [
        "# Sanity check:\n",
        "'''Un-comment this to see the coverage for each class.'''\n",
        "\n",
        "# count = [0,0,0,0,0,0,0,0,0,0]\n",
        "# for i in range(temp[2].shape[0]):\n",
        "#   count[temp[2][i]] += 1\n",
        "\n",
        "# print(count)\n",
        "# print(sum(count))"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Un-comment this to see the coverage for each class.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VP0X5ev3MxV-"
      },
      "source": [
        "### Enrichment Step 2\n",
        "\n",
        "Please ensure that there is sufficient RAM available to run this code. Insufficient RAM might lead to crashing of the notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uLKA6pjCNJgQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2f48c951-aff3-4741-de51-3dcfa4a4d312"
      },
      "source": [
        "NUMBER_OF_SAMPLES = 1000000\n",
        "\n",
        "temp = Enrichment(synthetic_data,synthetic_labels,model,1,20,NUMBER_OF_SAMPLES)\n",
        "\n",
        "new_synthetic_data = temp[0]\n",
        "new_synthetic_labels = temp[1]\n",
        "\n",
        "print(\"Training data shape: \",new_synthetic_data.shape)\n",
        "print(\"Training labels shape: \",new_synthetic_labels.shape)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1000000/1000000 [==============================] - 52s 52us/step\n",
            "Training data shape:  (1000000, 784)\n",
            "Training labels shape:  (1000000, 20)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Z8KN8vwTWP1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "49a7ff3f-a453-43d2-a228-2b769fcf3cad"
      },
      "source": [
        "# Sanity check:\n",
        "'''Un-comment this to see the coverage for each class.'''\n",
        "\n",
        "# count = [0,0,0,0,0,0,0,0,0,0]\n",
        "# for i in range(temp[2].shape[0]):\n",
        "#   count[temp[2][i]] += 1\n",
        "\n",
        "# print(count)\n",
        "# print(sum(count))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Un-comment this to see the coverage for each class.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IKkx_6UjMq23"
      },
      "source": [
        "## Visualizing the generated images\n",
        "\n",
        "Time to see how the generated images look like."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SAFGzWnBbKOz",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        },
        "outputId": "46f9a2c9-2bb4-4092-ce19-369fac95e9d0"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "\n",
        "for i in range(9):\n",
        "  plt.subplot(3,3,i+1)\n",
        "  plt.imshow(np.reshape(new_synthetic_data[i],(28,28)))"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 9 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w041KreasOJx"
      },
      "source": [
        "Now, after generating the synthetic data for MNIST Fashion, let us train the same neural network on MNIST Digits. We are going to mix the generated synthetic data with the training data of MNIST Digits."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ubvE_UbtmliJ"
      },
      "source": [
        "# Loading MNIST Digits dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YtVELtTRmoD8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f03e5d24-6755-48fa-ff7f-4863962443f4"
      },
      "source": [
        "from keras.datasets import mnist\n",
        "import copy\n",
        "\n",
        "(x_train_f, y_train_f), (x_test_f, y_test_f) = mnist.load_data()\n",
        "\n",
        "x_train_f = x_train_f/255\n",
        "x_test_f = x_test_f/255\n",
        "\n",
        "y_train_f = copy.deepcopy(y_train_f)\n",
        "y_test_f = copy.deepcopy(y_test_f)\n",
        "\n",
        "y_train_f += 10\n",
        "y_test_f += 10\n",
        "\n",
        "x_train_f = np.reshape(x_train_f,(60000,784))\n",
        "x_test_f = np.reshape(x_test_f,(10000,784))\n",
        "\n",
        "y_train_f = keras.utils.to_categorical(y_train_f,20)\n",
        "y_test_f = keras.utils.to_categorical(y_test_f,20)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading data from https://s3.amazonaws.com/img-datasets/mnist.npz\n",
            "11493376/11490434 [==============================] - 1s 0us/step\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TKBj17ktmwZH"
      },
      "source": [
        "# Training on digits while rehearsing fashion"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e13bl01Am9ug",
        "outputId": "8aea0469-1820-4fbc-cf3a-116dfce1dc99"
      },
      "source": [
        "print(\"Accuracy on MNIST Fashion: \",model.evaluate(x_test_h,y_test_h)[1])\n",
        "print(\"Accuracy on MNIST Digits: \",model.evaluate(x_test_f,y_test_f)[1])"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10000/10000 [==============================] - 1s 64us/step\n",
            "Accuracy on MNIST Fashion:  0.8762000203132629\n",
            "10000/10000 [==============================] - 1s 71us/step\n",
            "Accuracy on MNIST Digits:  0.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UbtaLYPSmzMq",
        "outputId": "1bef0525-72c2-47ec-8d4d-4a434ee1de7f"
      },
      "source": [
        "EPOCHS = 5\n",
        "\n",
        "learning_accuracy = []\n",
        "retention_accuracy = []\n",
        "\n",
        "for epoch in range(EPOCHS):\n",
        "  print(\"\\n Epoch number: \",epoch)\n",
        "  model.fit(x_train_f,y_train_f,epochs=1,batch_size=100,verbose=1)\n",
        "  model.fit(new_synthetic_data,new_synthetic_labels,verbose=1,epochs=1,batch_size=1000,shuffle=True)\n",
        "  \n",
        "  learning_accuracy.append(model.evaluate(x_test_f,y_test_f,verbose=1)[1])\n",
        "  retention_accuracy.append(model.evaluate(x_test_h,y_test_h,verbose=1)[1])\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Epoch number:  0\n",
            "Epoch 1/1\n",
            "60000/60000 [==============================] - 7s 110us/step - loss: 0.3051 - accuracy: 0.9147\n",
            "Epoch 1/1\n",
            "1000000/1000000 [==============================] - 31s 31us/step - loss: 0.5338 - accuracy: 0.7942\n",
            "10000/10000 [==============================] - 1s 69us/step\n",
            "10000/10000 [==============================] - 1s 74us/step\n",
            "\n",
            " Epoch number:  1\n",
            "Epoch 1/1\n",
            "60000/60000 [==============================] - 6s 105us/step - loss: 0.1089 - accuracy: 0.9676\n",
            "Epoch 1/1\n",
            "1000000/1000000 [==============================] - 31s 31us/step - loss: 0.4119 - accuracy: 0.8352\n",
            "10000/10000 [==============================] - 1s 69us/step\n",
            "10000/10000 [==============================] - 1s 70us/step\n",
            "\n",
            " Epoch number:  2\n",
            "Epoch 1/1\n",
            "60000/60000 [==============================] - 6s 108us/step - loss: 0.0709 - accuracy: 0.9789\n",
            "Epoch 1/1\n",
            "1000000/1000000 [==============================] - 31s 31us/step - loss: 0.3601 - accuracy: 0.8554\n",
            "10000/10000 [==============================] - 1s 70us/step\n",
            "10000/10000 [==============================] - 1s 66us/step\n",
            "\n",
            " Epoch number:  3\n",
            "Epoch 1/1\n",
            "60000/60000 [==============================] - 6s 105us/step - loss: 0.0528 - accuracy: 0.9837\n",
            "Epoch 1/1\n",
            "1000000/1000000 [==============================] - 31s 31us/step - loss: 0.3242 - accuracy: 0.8691\n",
            "10000/10000 [==============================] - 1s 74us/step\n",
            "10000/10000 [==============================] - 1s 70us/step\n",
            "\n",
            " Epoch number:  4\n",
            "Epoch 1/1\n",
            "60000/60000 [==============================] - 6s 104us/step - loss: 0.0390 - accuracy: 0.9884\n",
            "Epoch 1/1\n",
            "1000000/1000000 [==============================] - 31s 31us/step - loss: 0.2926 - accuracy: 0.8819\n",
            "10000/10000 [==============================] - 1s 70us/step\n",
            "10000/10000 [==============================] - 1s 73us/step\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tBBhT248nGGg",
        "outputId": "cf81c4eb-c496-4688-cabc-a5880bddc206"
      },
      "source": [
        "print(\"Accuracy on MNIST Fashion: \",model.evaluate(x_test_h,y_test_h)[1])\n",
        "print(\"Accuracy on MNIST Digits: \",model.evaluate(x_test_f,y_test_f)[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10000/10000 [==============================] - 1s 55us/step\n",
            "Accuracy on MNIST Fashion:  0.8169999718666077\n",
            "10000/10000 [==============================] - 1s 55us/step\n",
            "Accuracy on MNIST Digits:  0.9587000012397766\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R_7EjbHusqPS"
      },
      "source": [
        "You should observe an accuracy of around 80% for Fashion and 97% for Digits dataset. The accuracy on Fashion will be retained at about 80% even if we continue the training for 25 more epochs. This technique was tested on MNIST Fashion, MNIST Digits, CIFAR10 and SVHN dataset. Near-perfect retention was observed for CIFAR10 and SVHN datasets. It is still unclear why the technique achieves <b>near perfect retention</b> for some datasets while having a slight drop for others. This can be a good direction to investigate in the future. \n",
        "\n",
        "Now to see how the retention of the neural network is without rehearsing on synthetic data, let us train the neural network for 5 more epochs on MNIST Digits and record its accuracy on Fashion and Digits. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FlinmMbtvTEH",
        "outputId": "e5095f5b-60ec-4b6a-e6c7-cb66ab48de05"
      },
      "source": [
        "model.fit(x_train_f,y_train_f,epochs=5,batch_size=100,verbose=1)\n",
        "print(\"Accuracy on MNIST Fashion: \",model.evaluate(x_test_h,y_test_h)[1])\n",
        "print(\"Accuracy on MNIST Digits: \",model.evaluate(x_test_f,y_test_f)[1])"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/5\n",
            "60000/60000 [==============================] - 6s 105us/step - loss: 0.0300 - accuracy: 0.9909\n",
            "Epoch 2/5\n",
            "60000/60000 [==============================] - 6s 102us/step - loss: 0.0185 - accuracy: 0.9947\n",
            "Epoch 3/5\n",
            "60000/60000 [==============================] - 6s 103us/step - loss: 0.0136 - accuracy: 0.9963\n",
            "Epoch 4/5\n",
            "60000/60000 [==============================] - 6s 104us/step - loss: 0.0092 - accuracy: 0.9977\n",
            "Epoch 5/5\n",
            "60000/60000 [==============================] - 6s 105us/step - loss: 0.0061 - accuracy: 0.9986\n",
            "10000/10000 [==============================] - 1s 72us/step\n",
            "Accuracy on MNIST Fashion:  0.6237000226974487\n",
            "10000/10000 [==============================] - 1s 60us/step\n",
            "Accuracy on MNIST Digits:  0.9804999828338623\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f3pwgid2wisn"
      },
      "source": [
        "A significant drop in retention of Fashion dataset can be observed when we do not rehearse it."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ni9ppGUMwsaJ"
      },
      "source": [
        "# Concluding remarks\n",
        "\n",
        "This tutorial tried to demonstrate that neural networks can be pseudo rehearsed on synthetic data that is not photo-realistic. This comes in handy when we are trying to generate synthetic data for visually complex datasets like CIFAR10. In the original paper, the technique was demonstrated on MNIST Fashion, CIFAR10 and SVHN datasets. \n",
        "\n",
        "It is suggested to try generating synthetic data for other datasets as well! Make sure to play around with the parameters when you change the dataset. You might not find the optimal parameters for Genetic Algorithms on the first try, but please remember that, as of now, there is no theoretical framework/technique to estimate the optimal parameters for genetic algorithms. So keep playing around and use your intuition.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bv1V1sKvQ2u4"
      },
      "source": [
        "# This is being done to save space and prevent the program from crashing\n",
        "\n",
        "# del new_synthetic_data\n",
        "# del new_synthetic_labels"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g5-Hiea9M0vJ"
      },
      "source": [
        "## Cite this work as:\n",
        "\n",
        "@inproceedings{suri2021pseudo,<br>\n",
        "  title={Pseudo Rehearsal using non photo-realistic images},<br>\n",
        "  author={Suri, Bhasker Sri Harsha and Yeturu, Kalidas},<br>\n",
        "  booktitle={2020 25th International Conference on Pattern Recognition (ICPR)},<br>\n",
        "  pages={4797--4804},<br>\n",
        "  year={2021},<br>\n",
        "  organization={IEEE}}\n",
        "\n",
        "The full paper can be found at this <a href=\" https://ieeexplore.ieee.org/document/9412827\">link</a> and a pre-print version of it can be found <a href=\"https://arxiv.org/abs/2004.13414\">here</a>."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1FQMdVbW7Wjf"
      },
      "source": [
        "<u>Author of this notebook:</u>\n",
        "\n",
        "Name: Suri Bhasker Sri Harsha<br>\n",
        "Affiliation: Indian Institute of Technology Tirupati<br>\n",
        "Email: cs18s506@iittp.ac.in"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0s06MLau7mya"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}