CIFAR10.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "CIFAR10.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "F_AD0Kg7ZIav",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import os\n",
        "import keras\n",
        "import numpy as np\n",
        "import MOSA as mosa\n",
        "import tensorflow as tf\n",
        "from sklearn.model_selection import train_test_split\n",
        "from keras.utils import to_categorical\n",
        "import matplotlib.pyplot as plt\n",
        "from keras.datasets import cifar10"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Variables\n",
        "input_shape = [None, 32, 32, 3]\n",
        "number_of_classes = 10"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hDLtWk3YgZZ6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Load CIFAR-10 Dataset\n",
        "(x_train, y_train), (x_test, y_test) = cifar10.load_data()"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ejeOz0zASYyy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create Reduced Training Data\n",
        "# In order to speed up the search process, a reduced sample of 50% of the original training samples are selected randomly; \n",
        "# and 10% of this reduced sample is used as the reduced validation set.\n",
        "np.random.seed(226)\n",
        "Xtrain = np.empty((int(x_train.shape[0] / 2),32,32,3), dtype='uint8')\n",
        "Ytrain = np.empty(int(y_train.shape[0] / 2), dtype='uint8')\n",
        "Xtest = np.empty((int(x_test.shape[0] / 2),32,32,3), dtype='uint8')\n",
        "Ytest = np.empty((int(y_test.shape[0] / 2)), dtype='uint8')\n",
        "\n",
        "for i in range(int(x_train.shape[0] / 2)):\n",
        "    rnd = np.random.randint(0, x_train.shape[0])\n",
        "    Xtrain[i,:,:,:] = x_train[rnd,:,:,:]\n",
        "    Ytrain[i] = y_train[rnd]\n",
        "\n",
        "for j in range(int(x_test.shape[0] / 2)):\n",
        "    rnd = np.random.randint(0, y_test.shape[0])\n",
        "    Xtest[j,:,:,:] = x_test[rnd,:,:,:]\n",
        "    Ytest[j] = y_test[rnd]\n",
        "# -----------------------------------------------------"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lBFOZGjWcqqw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Convert output label to one hot vector\n",
        "Ytrain = to_categorical(Ytrain, number_of_classes)\n",
        "Ytest = to_categorical(Ytest, number_of_classes)\n",
        "# -----------------------------------------------------"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 10% of this reduced sample is used as the reduced validation set.\n",
        "Xtrain, Xvalid, Ytrain, Yvalid = train_test_split(Xtrain, Ytrain, \n",
        "                                                test_size = int(Xtrain.shape[0] * 0.1), random_state = 42)\n",
        "\n",
        "print(\"Shape of training features: {}\".format(Xtrain.shape))\n",
        "print(\"Shape of training lables: {}\".format(Ytrain.shape))\n",
        "print(\"Shape of testing features: {}\".format(Xvalid.shape))\n",
        "print(\"Shape of testing lables: {}\".format(Yvalid.shape))\n",
        "# -----------------------------------------------------"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Data Normalization\n",
        "Xtrain = Xtrain.astype('float32')\n",
        "Xvalid = Xvalid.astype('float32')\n",
        "Xtrain /= 255\n",
        "Xvalid /= 255\n",
        "# -----------------------------------------------------"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Set hyper-parameters\n",
        "learning_rate = 0.0001\n",
        "epoch = 50\n",
        "batch_size = 32"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# MOSA Parameters\n",
        "parameters = {'x_train': Xtrain , 'y_train': Ytrain, 'x_valid': Xvalid, 'y_valid': Yvalid, 'batch_size':batch_size, 'learning_rate':learning_rate}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Start MOSA Algorithm\n",
        "alg = mosa.MOSA(**parameters)\n",
        "alg.startAlgorithm()\n",
        "\n",
        "## Outputs: \n",
        " # model_history.txt: The loss and accuracy values (per epoch) of each model produced for training and validation are stored.\n",
        " # models.txt: Store iteration number, model_no, #parameters, Flops, train accuracy, validation accuracy and model topology\n",
        " # mosa_sols.pickle: It stores information about solutions on the Pareto front.\n",
        " # *.json files: Stores information about the topology of solutions on the Pareto front (Keras Model)."
      ]
    }
  ]
}