PixelNet_Pixel_Estimation_Notebook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "PixelNet - Pixel Estimation Notebook.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dean-sh/Pixel-Regression-with-Deep-Learning/blob/master/PixelNet_Pixel_Estimation_Notebook.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "metadata": {
        "id": "cYD34TAQQAd-",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# **PixelNet Notebook**\n",
        "\n",
        "This google-colab notebook contains the model architecture for the project.\n",
        "\n",
        "It also has the support for loading and saving the data in your own google-drive storage.\n",
        "\n",
        "## **The Dataset**\n",
        "\n",
        "\n",
        "1.   10,000 IR-Images of 31x31 pixels with gray-scale values of intensity.\n",
        "2.   The goal is to predict the value of the pixel in the center of the image.\n",
        "3.   The baseline for this prediction are the normal Open-CV types of interpolations.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "<img src=\"https://github.com/dean-sh/Pixel-Regression-with-Deep-Learning/raw/master/images/train_img1.png\" width=\"425\" height=\"350\" />\n"
      ]
    },
    {
      "metadata": {
        "id": "z1FdLUeLuUPR",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "###**File Handling For Google Colab**"
      ]
    },
    {
      "metadata": {
        "id": "UywyllJi9byU",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!apt-get install -y -qq software-properties-common python-software-properties module-init-tools\n",
        "!wget https://launchpad.net/~alessandro-strada/+archive/ubuntu/google-drive-ocamlfuse-beta/+build/15331130/+files/google-drive-ocamlfuse_0.7.0-0ubuntu1_amd64.deb\n",
        "!dpkg -i google-drive-ocamlfuse_0.7.0-0ubuntu1_amd64.deb\n",
        "!apt-get install -f\n",
        "!apt-get -y install -qq fuse\n",
        "from google.colab import auth\n",
        "auth.authenticate_user()\n",
        "from oauth2client.client import GoogleCredentials\n",
        "creds = GoogleCredentials.get_application_default()\n",
        "import getpass\n",
        "!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL\n",
        "vcode = getpass.getpass()\n",
        "!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}\n",
        "\n",
        "!mkdir -p drive\n",
        "!google-drive-ocamlfuse drive\n",
        "\n",
        "!ls"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "_sIcmBzGuPxv",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## **Training**"
      ]
    },
    {
      "metadata": {
        "id": "oJFAXr2_T4FZ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "imports:"
      ]
    },
    {
      "metadata": {
        "id": "6nKhqZ3lTmPS",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "import numpy as np\n",
        "# from PIL import Image\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, Dropout, Flatten, Reshape\n",
        "from keras.layers import Conv2D, MaxPooling2D\n",
        "from keras.layers.normalization import BatchNormalization\n",
        "from keras import backend as K\n",
        "import keras\n",
        "from keras.callbacks import TensorBoard\n",
        "import tensorflow as tf\n",
        "from keras.callbacks import ModelCheckpoint\n",
        "from sklearn.feature_extraction import image\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "brBk0UEPT9UR",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Dataset Creation and augmentation"
      ]
    },
    {
      "metadata": {
        "id": "YEnNthVOT3Vw",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def unpickle(pickled):\n",
        "    '''\n",
        "    This function unpickles tha files into dictionaries / arrays.\n",
        "    '''\n",
        "    import pickle\n",
        "    with open(pickled, 'rb') as fo:\n",
        "        file = pickle.load(fo)\n",
        "        fo.close()\n",
        "    return file\n",
        "\n",
        "def image_completion(image_set):\n",
        "    '''\n",
        "    This function completes the training images using the y value, \n",
        "    for augmentation purposes\n",
        "    '''\n",
        "    array = np.array(image_set['x_data'])\n",
        "    cnt = 0\n",
        "    for i in range(0, array.shape[0]):\n",
        "        array[i][15][15] = image_set['y_data'][i]\n",
        "        cnt+=1\n",
        "    return array\n",
        "\n",
        "  \n",
        "def data_augmentation(full_image_array, augment_size):\n",
        "    '''\n",
        "    This function takes the original full_image_array, and separates it into different image parts.\n",
        "    original full_image_array size is (10000, 31, 31, 1).\n",
        "    the output of the function is a  new, longer x_train, y_train, made by smaller images from the train set. \n",
        "    The catch is to have High variance in the augementation - and to not mix the test and train datasets using this augmentation.\n",
        "    '''\n",
        "\n",
        "    patches = image.extract_patches_2d(full_image_array[0], (augment_size, augment_size))\n",
        "    cnt = 0\n",
        "    for index in range(patches.shape[0]):\n",
        "        patch = image.extract_patches_2d(full_image_array[index], (augment_size, augment_size))\n",
        "        patches = np.concatenate((patches, patch), axis=0)\n",
        "    #creating new x_train, y_train\n",
        "    x_new_train = patches\n",
        "    center = int((augmentation_size-1)/2)\n",
        "    y_train = np.array((x_new_train[0][center][center]))\n",
        "    x_new_train[0][center][center] = 0\n",
        "\n",
        "    for index in range(1, x_new_train.shape[0]):\n",
        "        y_train = np.append(y_train, x_new_train[index][center][center])\n",
        "        x_new_train[index][center][center] = 0\n",
        "\n",
        "    y_train = np.expand_dims(y_train, 1)\n",
        "    x_train = x_new_train.reshape(x_new_train.shape[0], augmentation_size, augmentation_size, 1)\n",
        "    return x_train, y_train\n",
        "\n",
        "\n",
        "def plot_image(an_image):\n",
        "    plt.figure()\n",
        "    plt.imshow(an_image)\n",
        "    plt.colorbar()\n",
        "    plt.show(block=True)\n",
        "\n",
        "\n",
        "     \n",
        "def data_normalization(x, min, max):\n",
        "    \"\"\"\n",
        "    Normalize a list of sample image data in the range of 0 to 1\n",
        "    x: List of image data.  The image shape is (31, 31, 3)\n",
        "    return: Numpy array of normalized data\n",
        "    \"\"\"\n",
        "    #[-1, 1] normalization (did work, but the return back did not)\n",
        "    #return np.array(2*((x - min) / (max - min)) -1)\n",
        "    \n",
        "    #[0,1] normalization:\n",
        "    return np.array((x - min) / (max - min))\n",
        "\n",
        "Train\n",
        "val_set1 = unpickle('drive/train data/train_data_1000_31X31_ver9.pickle')\n",
        "val_set2 = unpickle('drive/train data/train_data_1000_31X31_ver10.pickle')\n",
        "val_set = {'x_data': [], 'y_data':[]}\n",
        "\n",
        "val_set['x_data'].extend(val_set1['x_data'])\n",
        "val_set['y_data'].extend(val_set1['y_data'])\n",
        "val_set['x_data'].extend(val_set2['x_data'])\n",
        "val_set['y_data'].extend(val_set2['y_data'])\n",
        "\n",
        "val_set['x_data'] = np.array(val_set['x_data'])\n",
        "val_set['y_data'] = np.array(val_set['y_data'])\n",
        "\n",
        "def data_set():\n",
        "    # Training set includes a dict with x-data and the y-data\n",
        "    train_set1 = unpickle('drive/train data/train_data_1000_31X31_ver1.pickle')\n",
        "    train_set2 = unpickle('drive/train data/train_data_1000_31X31_ver2.pickle')\n",
        "    train_set3 = unpickle('drive/train data/train_data_1000_31X31_ver3.pickle')\n",
        "    train_set4 = unpickle('drive/train data/train_data_1000_31X31_ver4.pickle')\n",
        "    train_set5 = unpickle('drive/train data/train_data_1000_31X31_ver5.pickle')\n",
        "    train_set6 = unpickle('drive/train data/train_data_1000_31X31_ver6.pickle')\n",
        "    train_set7 = unpickle('drive//train data/train_data_1000_31X31_ver7.pickle')\n",
        "    train_set8 = unpickle('drive/train data/train_data_1000_31X31_ver8.pickle')\n",
        "\n",
        "    train_set = {'x_data': [], 'y_data':[]}\n",
        "    train_set['x_data'].extend(train_set1['x_data'])\n",
        "    train_set['y_data'].extend(train_set1['y_data'])\n",
        "    train_set['x_data'].extend(train_set2['x_data'])\n",
        "    train_set['y_data'].extend(train_set2['y_data'])\n",
        "    train_set['x_data'].extend(train_set3['x_data'])\n",
        "    train_set['y_data'].extend(train_set3['y_data'])\n",
        "    train_set['x_data'].extend(train_set4['x_data'])\n",
        "    train_set['y_data'].extend(train_set4['y_data'])\n",
        "    train_set['x_data'].extend(train_set5['x_data'])\n",
        "    train_set['y_data'].extend(train_set5['y_data'])\n",
        "    train_set['x_data'].extend(train_set6['x_data'])\n",
        "    train_set['y_data'].extend(train_set6['y_data'])\n",
        "    train_set['x_data'].extend(train_set7['x_data'])\n",
        "    train_set['y_data'].extend(train_set7['y_data'])\n",
        "    train_set['x_data'].extend(train_set8['x_data'])\n",
        "    train_set['y_data'].extend(train_set8['y_data'])\n",
        "\n",
        "    train_set['x_data'] = np.array(train_set['x_data'])\n",
        "    train_set['y_data'] = np.array(train_set['y_data'])\n",
        "\n",
        "    del(train_set1, train_set2, train_set3, train_set4, train_set5, train_set6, train_set7, train_set8)#, train_set9, train_set10)\n",
        "    return train_set\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "tuQfJt3fUcV_",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#Train-Val-Test Creation and Augmentation\n",
        "train_set = data_set()\n",
        "\n",
        "augmentation_size = 7 \n",
        "'''\n",
        "This means that after completing the image, \n",
        "We will get many 7X7 images!\n",
        "'''\n",
        "\n",
        "\n",
        "\n",
        "full_image_array = image_completion(train_set)\n",
        "full_image_array = full_image_array.astype(int)\n",
        "\n",
        "full_val_array = image_completion(val_set)\n",
        "full_val_array = full_image_array.astype(int)\n",
        "\n",
        "val_min = np.min(np.min(np.where(full_val_array==0, full_val_array.max(), full_val_array), axis=1))\n",
        "val_max = np.max(np.max(np.where(full_val_array==0, full_val_array.min(), full_val_array), axis=1))\n",
        "\n",
        "minval = np.min(np.min(np.where(full_image_array==0, full_image_array.max(), full_image_array), axis=1))\n",
        "\n",
        "maxval = np.max(np.max(np.where(full_image_array==0, full_image_array.min(), full_image_array), axis=1))\n",
        "\n",
        "print(full_image_array.shape)\n",
        "\n",
        "norm_x = data_normalization(full_image_array, minval, maxval)\n",
        "\n",
        "val_norm_x = data_normalization(full_val_array, val_min, val_max)\n",
        "\n",
        "\n",
        "\n",
        "input_size = (augmentation_size, augmentation_size, 1)\n",
        "img_x, img_y = augmentation_size, augmentation_size\n",
        "\n",
        "\n",
        "(new_x_val, new_y_val) = data_augmentation(val_norm_x, augmentation_size)\n",
        "new_x_val = np.squeeze(np.reshape(new_val_x, (new_val_x.shape[0], img_y*img_x)))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "LVJ0acJLU3bE",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Handling the augmentation process:"
      ]
    },
    {
      "metadata": {
        "id": "UuR_6aiJU2uo",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def input_handling_and_saving():\n",
        "    \n",
        "    '''\n",
        "    This function augments the data and saves it to Google Drive.\n",
        "    '''\n",
        "    (x_train, y_train) = data_augmentation(norm_x, augmentation_size)\n",
        "\n",
        "    input_size = img_x*img_y\n",
        "\n",
        "    X_sptrain, X_sptest, y_sptrain, y_sptest = train_test_split(x_train, y_train, test_size=0.2, random_state=42)\n",
        "\n",
        "    y_test = y_sptest\n",
        "    x_test = X_sptest\n",
        "\n",
        "    X_sptrain2, X_sptest2, y_sptrain2, y_sptest2 = train_test_split(X_sptrain, y_sptrain, test_size=0.2, random_state=42)\n",
        "    \n",
        "    # convert the data to the right type\n",
        "    x_train = X_sptrain2\n",
        "    y_train = y_sptrain2\n",
        "\n",
        "    x_val = X_sptest2\n",
        "    y_val = y_sptest2\n",
        "\n",
        "    x_train = np.squeeze(np.reshape(x_train, (x_train.shape[0], img_y*img_x)))\n",
        "    x_test = np.squeeze(np.reshape(x_test, (x_test.shape[0], img_y*img_x)))\n",
        "    x_val = np.squeeze(np.reshape(x_val, (x_val.shape[0], img_y*img_x)))\n",
        "\n",
        "    np.save('drive/x_train_aug11', x_train)\n",
        "    np.save('drive/y_train_aug11', y_train)\n",
        "\n",
        "    np.save('drive/x_val_aug11', x_val)\n",
        "    np.save('drive/y_val_aug11', y_val)\n",
        "\n",
        "    np.save('drive/x_test_aug11', x_test)\n",
        "    np.save('drive/y_test_aug11', y_test)\n",
        "    return x_train, y_train, x_val, y_val, x_test, y_test \n",
        "\n",
        "\n",
        "\n",
        "def input_loading():\n",
        "    '''\n",
        "    This function loads the previously created and augmented images.\n",
        "    '''\n",
        "    \n",
        "    x_train = np.load('drive/x_train_aug11.npy')\n",
        "    y_train = np.load('drive/y_train_aug11.npy')\n",
        "\n",
        "    x_val = np.load('drive/x_val_aug11.npy')\n",
        "    y_val = np.load('drive/y_val_aug11.npy')\n",
        "\n",
        "    x_test = np.load('drive/x_test_aug11.npy')\n",
        "    y_test = np.load('drive/y_test_aug11.npy')\n",
        "\n",
        "    return x_train, y_train, x_val, y_val, x_test, y_test \n",
        "\n",
        "#Augmenting and saving:\n",
        "(x_train, y_train, x_val, y_val, x_test, y_test) = input_handling_and_saving()\n",
        "\n",
        "#When starting from previously augmented data:\n",
        "(x_train, y_train, x_val, y_val, x_test, y_test) = input_loading()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "uh3JjyfJV9ta",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Finally - Training the PixelNet.\n",
        "**I've used several architectures - some of which where CNN based, others where Dense Nets.\n",
        "This code converts the data between 4d NP array if needed**"
      ]
    },
    {
      "metadata": {
        "id": "xdBm6yYo2A_-",
        "colab_type": "code",
        "outputId": "08aa977a-7be4-43a8-bc56-5374ca5492a5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "cell_type": "code",
      "source": [
        "#######################################\n",
        "#CNN -> FC method: these lines convert the input data to 4d numpy image.\n",
        "x_train = np.reshape(x_train, (x_train.shape[0], augmentation_size, augmentation_size, 1))\n",
        "x_test = np.reshape(x_test, (x_test.shape[0], augmentation_size, augmentation_size, 1))\n",
        "x_val = np.reshape(x_val, (x_val.shape[0], augmentation_size, augmentation_size, 1))\n",
        "new_x_val = np.reshape(new_x_val, (new_x_val.shape[0], augmentation_size, augmentation_size, 1))\n",
        "########################################\n",
        "\n",
        "\n",
        "print('train shape:', x_train.shape, y_train.shape)\n",
        "print(x_train.shape[0], 'train samples')\n",
        "print('val shape', x_val.shape, y_val.shape)\n",
        "print(x_val.shape[0], 'val samples')\n",
        "print('test shape', x_test.shape, y_test.shape)\n",
        "print(x_test.shape[0], 'test samples')\n",
        "print('New \"unseen\" Validation shape', new_x_val.shape, new_y_val.shape)\n",
        "print(x_test.shape[0], 'test samples')\n",
        "\n",
        "\n",
        "\n",
        "# plot_image(np.reshape(x_train[random.randrange(1,500)], (augmentation_size,augmentation_size)))\n",
        "# plot_image(np.reshape(x_test[random.randrange(1,500)], (augmentation_size,augmentation_size)))\n",
        "# plot_image(np.reshape(x_val[random.randrange(1,500)], (augmentation_size,augmentation_size)))\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(8000, 31, 31, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "f8tN1xIXWhEc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Model architecture and fit:"
      ]
    },
    {
      "metadata": {
        "id": "Ss7Yrba1WZuj",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "batch_size = 64\n",
        "epochs =100\n",
        "\n",
        "\n",
        "model = Sequential()\n",
        "model.add(Conv2D(16, (5, 5), strides = (2,2), padding='same', activation='relu', input_shape = input_size))\n",
        "model.add(Conv2D(32, (5, 5), strides = (1,1), padding='same', activation='relu'))\n",
        "model.add(Conv2D(64, (3, 3), strides = (2,2), padding='same', activation='relu'))\n",
        "model.add(Conv2D(128, (3, 3), strides = (1,1), padding='same', activation='relu'))\n",
        "\n",
        "model.add(Flatten())\n",
        "model.add(Dense(512, activation='relu', kernel_initializer='normal'))\n",
        "model.add(Dropout(0.05))\n",
        "model.add(Dense(100, activation='relu', kernel_initializer='normal'))\n",
        "model.add(Dense(10, activation='relu', kernel_initializer='normal'))\n",
        "\n",
        "model.add(Dense(1, kernel_initializer='normal'))\n",
        "\n",
        "def R2(y_true, y_pred):\n",
        "    SS_res =  K.sum(K.square( y_true-y_pred )) \n",
        "    SS_tot = K.sum(K.square( y_true - K.mean(y_true) ) ) \n",
        "    return ( 1 - SS_res/(SS_tot + K.epsilon()) )\n",
        "\n",
        "\n",
        "filepath='drive/Regression_CNN_6_1.weights-improvement-{epoch:02d}.h5'\n",
        "mc = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='auto', save_weights_only=True)\n",
        "\n",
        "tbCallBack = TensorBoard(log_dir='./log', histogram_freq=1,\n",
        "                         write_graph=True,\n",
        "                         write_grads=True,\n",
        "                         batch_size=batch_size,\n",
        "                         write_images=True)\n",
        "\n",
        "model.compile(optimizer='adam', loss='mean_squared_error')#, metrics=[R2])\n",
        "\n",
        "history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1,\n",
        "                    validation_data=(x_val, y_val),\n",
        "                    shuffle=True,\n",
        "                    callbacks=[mc])#, tbCallBack])\n",
        "\n",
        "score = model.evaluate(x_test, y_test, verbose=1)\n",
        "\n",
        "#TODO plot the val_loss to epochs.\n",
        "\n",
        "print('Test loss:', score)\n",
        "\n",
        "# Loss Curves\n",
        "plt.figure(figsize=[8, 6])\n",
        "plt.plot(history.history['loss'], 'r', linewidth=3.0)\n",
        "plt.plot(history.history['val_loss'], 'b', linewidth=3.0)\n",
        "plt.legend(['Training loss', 'Validation Loss'], fontsize=18)\n",
        "plt.xlabel('Epochs ', fontsize=16)\n",
        "plt.ylabel('Loss', fontsize=16)\n",
        "plt.title('Loss Curves', fontsize=16)\n",
        "plt.show(block=True)\n",
        "\n",
        "from keras.models import load_model\n",
        "\n",
        "model.save('drive/Regression_CNN_6_1.h5')  # creates a HDF5 file 'my_model.h5'\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "_4VOjUXUJfni",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### **Continue training from saved model**"
      ]
    },
    {
      "metadata": {
        "id": "WZuZNaO0XKeK",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "model.compile(optimizer='adam', loss='mean_squared_error')\n",
        "\n",
        "# score = model.evaluate(x_test, y_test, verbose=1)\n",
        "print('Test loss:', score)\n",
        "\n",
        "\n",
        "def R2(y_true, y_pred):\n",
        "    SS_res =  K.sum(K.square( y_true-y_pred )) \n",
        "    SS_tot = K.sum(K.square( y_true - K.mean(y_true) ) ) \n",
        "    return ( 1 - SS_res/(SS_tot + K.epsilon()) )\n",
        "\n",
        "\n",
        "\n",
        "epochs = 500\n",
        "filepath='drive/Regression_CNN_5_2.weights-improvement-{epoch:02d}.h5'\n",
        "mc = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='auto', save_weights_only=True)\n",
        "\n",
        "tbCallBack = TensorBoard(log_dir='./log', histogram_freq=1,\n",
        "                         write_graph=True,\n",
        "                         write_grads=True,\n",
        "                         batch_size=batch_size,\n",
        "                         write_images=True)\n",
        "\n",
        "model.compile(optimizer='adam', loss='mean_squared_error', metrics=[R2])\n",
        "\n",
        "history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1,\n",
        "                    validation_data=(x_val, y_val),\n",
        "                    shuffle=True,\n",
        "                    callbacks=[mc])\n",
        "\n",
        "score = model.evaluate(x_test, y_test, verbose=1)\n",
        "\n",
        "\n",
        "# Loss Curves\n",
        "plt.figure(figsize=[8, 6])\n",
        "plt.plot(history.history['loss'], 'r', linewidth=3.0)\n",
        "plt.plot(history.history['val_loss'], 'b', linewidth=3.0)\n",
        "plt.legend(['Training loss', 'Validation Loss'], fontsize=18)\n",
        "plt.xlabel('Epochs ', fontsize=16)\n",
        "plt.ylabel('Loss', fontsize=16)\n",
        "plt.title('Loss Curves', fontsize=16)\n",
        "plt.show(block=True)\n",
        "model.save('drive/Regression_CNN_4_3.h5')  # creates a HDF5 file 'my_model.h5'\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "-7ZtmV8KD6FK",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### **Regression LIft Chart**"
      ]
    },
    {
      "metadata": {
        "id": "n_kxhwtaDXre",
        "colab_type": "code",
        "outputId": "f92693a1-c274-42cc-d08f-d2ae2bad67f8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        }
      },
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "model.load_weights('drive/Regression_CNN_5_1.weights-improvement-61.h5')\n",
        "model.compile(optimizer='adam', loss='mean_squared_error')\n",
        "\n",
        "# Regression chart.\n",
        "def chart_regression(pred,y,sort=True):\n",
        "    t = pd.DataFrame({'pred' : pred, 'y' : y.flatten()})\n",
        "    if sort:\n",
        "        t.sort_values(by=['y'],inplace=True)\n",
        "    b = plt.plot(t['pred'].tolist(),label='prediction')\n",
        "\n",
        "    a = plt.plot(t['y'].tolist(),label='expected')\n",
        "    plt.ylabel('output')\n",
        "    plt.legend()\n",
        "    plt.show()\n",
        "\n",
        "    \n",
        "# Predict and measure RMSE\n",
        "predict = model.predict(x_test[0:500])\n",
        "# score = np.sqrt(metrics.mean_squared_error(pred,y_test))\n",
        "# print(\"Score (RMSE): {}\".format(score))\n",
        "\n",
        "# Plot the chart\n",
        "chart_regression(predict.flatten(),y_test[0:500])\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAD4CAYAAAAD6PrjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAGASBQAmUQBgEgUAJlEAYBIFAKY3mTk2N/LOl+QAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x7fa27ff31518>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "ODt6ijzP4dfo",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### **R-Squared chart**"
      ]
    },
    {
      "metadata": {
        "id": "PAndRlJ_40Uo",
        "colab_type": "code",
        "outputId": "222d77f2-bafa-4b32-a0fe-6b95238ca759",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        }
      },
      "cell_type": "code",
      "source": [
        "Y_test = y_test[2000:2200] # Random Data\n",
        "Y_pred = model.predict(x_test[2000:2200])\n",
        "\n",
        "\n",
        "def r2_keras(y_true, y_pred):\n",
        "    ssres = np.sum(np.square(y_true - y_pred))\n",
        "    sstot = np.sum(np.square(y_true - np.mean(y_pred)))\n",
        "    return 1 - ssres / sstot\n",
        "\n",
        "r_squared = r2_keras(Y_test, Y_pred)\n",
        "\n",
        "plt.scatter(Y_test,Y_pred)\n",
        "plt.xlabel('Actual values')\n",
        "plt.ylabel('Predicted values')\n",
        "\n",
        "plt.text(0.2, 0.2, 'R-squared = %0.2f' % r_squared)\n",
        "plt.show()\n",
        "print(r_squared)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEGCAYAAACO8lkDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x7fa27f60b1d0>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "0.9870264058502616\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "yTpY5DSwHyWB",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### **Testing the model**"
      ]
    },
    {
      "metadata": {
        "id": "i6ZjtROVEBFa",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Test Loss after keras checkpoint**"
      ]
    },
    {
      "metadata": {
        "id": "ANoB5JhQ14RU",
        "colab_type": "code",
        "outputId": "3942984a-87fb-4f0c-d059-135f2c191b20",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "cell_type": "code",
      "source": [
        "model.load_weights('drive/Regression_CNN_5_1.weights-improvement-61.h5')\n",
        "model.compile(optimizer='adam', loss='mean_squared_error')\n",
        "\n",
        "# score = model.evaluate(x_test, y_test, verbose=1)\n",
        "model.save('drive/Regression_CNN_5_model.h5')\n",
        "from keras.models import load_model\n",
        "\n",
        "model2 = load_model('drive/Regression_CNN_5_model.h5')\n",
        "score = model2.evaluate(x_test, y_test, verbose=1)\n",
        "print('Test loss:', score)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "75125/75125 [==============================] - 7s 87us/step\n",
            "Test loss: 2.9250108120891695e-05\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "fU7CoUhUELUA",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### **MSE over Test Set**"
      ]
    },
    {
      "metadata": {
        "id": "SDpG6SL9a4ch",
        "colab_type": "code",
        "outputId": "8174ee53-0447-442c-c2b1-067fc0747dec",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "cell_type": "code",
      "source": [
        "%matplotlib inline \n",
        "\n",
        "import math\n",
        "model.load_weights('drive/Regression_CNN_5_1.weights-improvement-61.h5')\n",
        "model.compile(optimizer='adam', loss='mean_squared_error')\n",
        "\n",
        "#MSE over test set:\n",
        "len = 75000\n",
        "\n",
        "ms = []\n",
        "acc = 0\n",
        "abs_acc = 0\n",
        "norm_acc = 0\n",
        "cnt = 0\n",
        "\n",
        "for i in range(1,len):\n",
        "    \n",
        "    #FC prediction:\n",
        "    #expanded_im = np.expand_dims(x_test[a], axis=0)\n",
        "    #reshaped_img = np.reshape(expanded_im, (1, 121))\n",
        "    #prediction = model2.predict(reshaped_img)[0][0]\n",
        "\n",
        "    #CNN prediction:\n",
        "    reshaped_img = np.reshape(x_test[i], (augmentation_size,augmentation_size))\n",
        "    expanded_im = np.expand_dims(reshaped_img, axis=0)\n",
        "    expanded_im = np.expand_dims(expanded_im, axis=3)\n",
        "    prediction = model.predict(expanded_im)\n",
        "\n",
        "    #conversion to non-normalized images\n",
        "\n",
        "    original_y_val = int((maxval-minval)*y_test[i][0] + minval)\n",
        "    original_pred_val = int((maxval-minval)*prediction + minval)\n",
        "\n",
        "    diff = original_pred_val - original_y_val\n",
        "    ms.append(diff)\n",
        "    acc += abs(original_pred_val-original_y_val)\n",
        "    abs_acc = acc*acc\n",
        "    cnt+=1\n",
        "    norm_acc += abs(prediction - y_test[a][0]) \n",
        "\n",
        "import statistics as s\n",
        "mse = s.mean([i ** 2 for i in ms])\n",
        "print('MSE:',mse)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "MSE: 148.07944105921413\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "w0R46CPut-t7",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Comparing two models: (currently for Dense-Fully Connected models only)"
      ]
    },
    {
      "metadata": {
        "id": "AQUN95o-dEI4",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#model 3 - B - the best performing model yet (FC4_1)\n",
        "#model 2 - A - Newly trained model (from test segment)\n",
        "\n",
        "model3 = Sequential()\n",
        "model3.add(Dense(512, activation='relu', input_dim=input_size, kernel_initializer='normal'))\n",
        "model3.add(Dropout(0.05))\n",
        "model3.add(Dense(512, activation='relu', input_dim=input_size, kernel_initializer='normal'))\n",
        "model3.add(Dropout(0.05))\n",
        "model3.add(Dense(1, kernel_initializer='normal'))\n",
        "\n",
        "model3.load_weights('drive/FC-regression-augmentation_FC#4_1.h5')\n",
        "model3.compile(optimizer='adam', loss='mean_squared_error')\n",
        "\n",
        "import math\n",
        "\n",
        "#comparing two models\n",
        "\n",
        "len = 100\n",
        "msA = []\n",
        "msB = []\n",
        "acc = 0\n",
        "abs_acc = 0\n",
        "norm_acc = 0\n",
        "cnt = 0\n",
        "\n",
        "\n",
        "for i in range(1,len):\n",
        "    a = random.randrange(1,50000)\n",
        "    expanded_im = np.expand_dims(x_test[a], axis=0)\n",
        "    reshaped_img = np.reshape(expanded_im, (1, augmentation_size**2))\n",
        "    predictionA = model2.predict(reshaped_img)[0][0]\n",
        "    predictionB = model3.predict(reshaped_img)[0][0]\n",
        "\n",
        "    #CNN prediction:\n",
        "    model2.predict(np.expand_dims(reshaped_img, axis=0))\n",
        "\n",
        "    #conversion to non-normalized images\n",
        "    original_y_val = int((maxval-minval)*y_test[a][0] + minval)\n",
        "    original_pred_val_A = ((maxval-minval)*predictionA + minval)\n",
        "    original_pred_val_B = ((maxval-minval)*predictionB + minval)\n",
        "\n",
        "    diffA = original_pred_val_A - original_y_val\n",
        "    diffB = original_pred_val_B - original_y_val\n",
        "\n",
        "    msA.append(diffA)\n",
        "    msB.append(diffB)\n",
        "    \n",
        "    \n",
        "import statistics as s\n",
        "mseA = s.mean([i ** 2 for i in msA])\n",
        "print('MSE A:',mseA)\n",
        "mseB = s.mean([i ** 2 for i in msB])\n",
        "print('MSE B:',mseB)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "p7T07PyHnrhN",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### **Image completion test**"
      ]
    },
    {
      "metadata": {
        "id": "o_cVx8s1nvJp",
        "colab_type": "code",
        "outputId": "2a1bab73-34e6-4ac9-8f03-f19fb686c4e2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1369
        }
      },
      "cell_type": "code",
      "source": [
        "%matplotlib inline\n",
        "\n",
        "from matplotlib import cm\n",
        "plt.rcParams['image.cmap'] = 'plasma'\n",
        "\n",
        "model.load_weights('drive/Regression_CNN_5_1.weights-improvement-61.h5')\n",
        "model.compile(optimizer='adam', loss='mean_squared_error')\n",
        "\n",
        "\n",
        "#Plot X_TEST images with the predicted value (WITH y_true value)\n",
        "\n",
        "from pylab import *\n",
        "import random \n",
        "for i in range(1,1):\n",
        "    a = random.randrange(1,50000)\n",
        "\n",
        "    #FC prediction:\n",
        "\n",
        "    #expanded_im = np.expand_dims(x_test[a], axis=0)\n",
        "    #reshaped_img = np.reshape(expanded_im, (1, 121))\n",
        "    #prediction = model2.predict(reshaped_img)[0][0]\n",
        "\n",
        "    #CNN prediction:\n",
        "    reshaped_img = np.reshape(x_test[a], (augmentation_size,augmentation_size))\n",
        "    expanded_im = np.expand_dims(reshaped_img, axis=0)\n",
        "    expanded_im = np.expand_dims(expanded_im, axis=3)\n",
        "    #   print(expanded_im.shape)\n",
        "    prediction = model.predict(expanded_im)\n",
        "\n",
        "    Original_image = reshaped_img\n",
        "    Original_image[int(augmentation_size/2)][int(augmentation_size/2)] = y_test[a]\n",
        "    Original_image = ((maxval-minval)*Original_image + minval)\n",
        "\n",
        "    predicted_image = reshaped_img\n",
        "    predicted_image[int(augmentation_size/2)][int(augmentation_size/2)] = prediction\n",
        "    predicted_image = ((maxval-minval)*predicted_image + minval)\n",
        "    plt.figure(figsize=(6, 4))\n",
        "\n",
        "\n",
        "    fig, axs = plt.subplots(1, 2, figsize=(13, 6))\n",
        "    axs[0].imshow(Original_image)\n",
        "    axs[0].set_title('Original_image')\n",
        "\n",
        "    axs[1].imshow(predicted_image)\n",
        "    axs[1].set_title('predicted_image')\n",
        "\n",
        "    print('True Value:', Original_image[int(augmentation_size/2)][int(augmentation_size/2)], 'Predicted:', predicted_image[int(augmentation_size/2)][int(augmentation_size/2)])\n",
        "\n",
        "def crop_center_for_nn(img,crop):\n",
        "    y,x = img.shape\n",
        "    startx = x//2 - crop//2\n",
        "    starty = y//2 - crop//2\n",
        "    return img[starty:starty+crop, startx:startx+crop]\n",
        "\n",
        "\n",
        "test_set1 = unpickle('drive/test data/test1_data_2000_31X31_dataOnly.pickle')\n",
        "test_set2 = unpickle('drive/test data/test2_data_2000_31X31_dataOnly.pickle')\n",
        "test_set = np.concatenate((test_set1, test_set2), axis=0)\n",
        "\n",
        "normalized_test_set = data_normalization(test_set, minval, maxval)\n",
        "\n",
        "\n",
        "def test_31_sized_img(test_image):\n",
        "    test_img = np.squeeze(test_image)\n",
        "    center_img = crop_center_for_nn(test_img, augmentation_size)\n",
        "    expanded_im = np.expand_dims(center_img, axis=0)\n",
        "    center_img11 = np.expand_dims(expanded_im, axis=3)\n",
        "\n",
        "    return center_img11, test_img\n",
        "\n",
        "###################################################################################\n",
        "#Plot Test_set images with the predicted value (without y_true value)\n",
        "\n",
        "for i in range(1,2):\n",
        "    a = random.randrange(1,4000)\n",
        "    test_image = normalized_test_set[a]\n",
        "    (center_image, full_image) = test_31_sized_img(test_image)\n",
        "  \n",
        "\n",
        "    center_image[:,int(augmentation_size/2),int(augmentation_size/2),:] = 0\n",
        "    print(center_image)\n",
        "    prediction = model.predict(center_image)\n",
        "    print(prediction)\n",
        "\n",
        "    #   full_image[15][15] = prediction\n",
        "\n",
        "    full_image = ((maxval-minval)*full_image + minval)\n",
        "    plt.figure(figsize=(9, 7))\n",
        "\n",
        "    plt.imshow(full_image)\n",
        "\n",
        "    plt.colorbar()\n",
        "    plt.show(block=True)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[[[0.1680747 ]\n",
            "   [0.1596265 ]\n",
            "   [0.14628724]\n",
            "   [0.13872832]\n",
            "   [0.12850156]\n",
            "   [0.17074255]\n",
            "   [0.16007114]]\n",
            "\n",
            "  [[0.14050689]\n",
            "   [0.17429969]\n",
            "   [0.17118719]\n",
            "   [0.16362828]\n",
            "   [0.18586038]\n",
            "   [0.1511783 ]\n",
            "   [0.1342819 ]]\n",
            "\n",
            "  [[0.15784793]\n",
            "   [0.1849711 ]\n",
            "   [0.20231214]\n",
            "   [0.21476212]\n",
            "   [0.16985327]\n",
            "   [0.13917297]\n",
            "   [0.18541574]]\n",
            "\n",
            "  [[0.19075145]\n",
            "   [0.23432637]\n",
            "   [0.23654958]\n",
            "   [0.        ]\n",
            "   [0.1511783 ]\n",
            "   [0.18852823]\n",
            "   [0.23432637]]\n",
            "\n",
            "  [[0.23210316]\n",
            "   [0.22854602]\n",
            "   [0.18141396]\n",
            "   [0.16540685]\n",
            "   [0.19697643]\n",
            "   [0.23832815]\n",
            "   [0.25833704]]\n",
            "\n",
            "  [[0.22054246]\n",
            "   [0.17029791]\n",
            "   [0.16851934]\n",
            "   [0.15606936]\n",
            "   [0.21609604]\n",
            "   [0.25878168]\n",
            "   [0.24321921]]\n",
            "\n",
            "  [[0.15784793]\n",
            "   [0.17163184]\n",
            "   [0.20320142]\n",
            "   [0.2103157 ]\n",
            "   [0.25433526]\n",
            "   [0.24722099]\n",
            "   [0.20097821]]]]\n",
            "[[0.19699639]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeYAAAGbCAYAAAARLzPQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQuiYAQCIEDpmAAAi5P8CyYtwrHaGVccAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x7f3983886860>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "xaiDS_ebIdOb",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### **Plot Model Architecture**"
      ]
    },
    {
      "metadata": {
        "id": "YCkXZGN9EYdH",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import IPython\n",
        "from keras.utils import plot_model\n",
        "!apt-get -qq install -y graphviz && !pip install -q pydot\n",
        "# import pydot\n",
        "\n",
        "plot_model(model, to_file='drive/model.png')\n"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}