v3_ft_multi_mnist_test.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Improved CNN for FT of MNIST data. Also padded size.\n",
    "\n",
    "### v3 introduces 2 channels of intensity and phase to see if accuracy improves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "apJbCsBHl-2A"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "#Choose GPUs and CPUs\n",
    "\n",
    "import tensorflow as tf\n",
    "import keras\n",
    "from keras import backend as K\n",
    "from keras.datasets import mnist\n",
    "\n",
    "#If want to choose GPU to use\n",
    "#This will make it so that only the 0th GPU is visible to TensorFlow.\n",
    "#In your case, you can choose any in the range [0, 3].\n",
    "#If you wanted, for example, the 0th and 2nd GPUs to both be visible, replace \"0\" with \"0,2\"\n",
    "import os\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0,1\"\n",
    "\n",
    "GPU=True\n",
    "CPU=False\n",
    "num_cores = 8\n",
    "\n",
    "if GPU:\n",
    "    num_GPU = 2\n",
    "    num_CPU = 2\n",
    "if CPU:\n",
    "    num_CPU = num_cores\n",
    "    num_GPU = 0\n",
    "\n",
    "config = tf.ConfigProto(intra_op_parallelism_threads=num_cores,\\\n",
    "        inter_op_parallelism_threads=num_cores, allow_soft_placement=True,\\\n",
    "        device_count = {'CPU' : num_CPU, 'GPU' : num_GPU},\\\n",
    "#        gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.5))\n",
    "                       )\n",
    "config.gpu_options.allow_growth = True\n",
    "\n",
    "session = tf.Session(config=config)\n",
    "K.set_session(session)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from six.moves.urllib.request import urlretrieve\n",
    "from six.moves import cPickle as pickle\n",
    "\n",
    "\n",
    "from keras.layers import Conv2D, MaxPool2D\n",
    "from keras.models import Sequential, Model\n",
    "from keras.layers import Dense, Dropout, Activation, Flatten\n",
    "from keras.utils import to_categorical, multi_gpu_model\n",
    "\n",
    "from tqdm import tqdm_notebook, tnrange\n",
    "\n",
    "from scipy.fftpack import fftn,fftshift\n",
    "#from skimage.restoration import unwrap_phase\n",
    "\n",
    "\n",
    "# Config the matplotlib backend as plotting inline in IPython\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load MNIST data from Keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_dataset shape: (60000, 28, 28, 1)\n",
      "60000 train samples\n",
      "10000 test samples\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# input image dimensions\n",
    "img_rows, img_cols = 28, 28\n",
    "num_classes=10\n",
    "\n",
    "# the data, split between train and test sets\n",
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
    "\n",
    "if K.image_data_format() == 'channels_first':\n",
    "    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)\n",
    "    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)\n",
    "    input_shape = (1, img_rows, img_cols)\n",
    "else:\n",
    "    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\n",
    "    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\n",
    "    input_shape = (img_rows, img_cols, 1)\n",
    "\n",
    "train_dataset = x_train.astype('float32')\n",
    "test_dataset = x_test.astype('float32')\n",
    "train_dataset /= 255\n",
    "test_dataset /= 255\n",
    "print('train_dataset shape:', x_train.shape)\n",
    "print(x_train.shape[0], 'train samples')\n",
    "print(x_test.shape[0], 'test samples')\n",
    "\n",
    "# convert class vectors to binary class matrices\n",
    "train_labels = keras.utils.to_categorical(y_train, num_classes)\n",
    "test_labels = keras.utils.to_categorical(y_test, num_classes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pad numpy array \n",
    "Want get 36x36 which is how much the multiMNIST will be"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60000, 36, 36, 1)\n",
      "(10000, 36, 36, 1)\n"
     ]
    }
   ],
   "source": [
    "train_dataset=np.pad(train_dataset, ((0,0),(4,4),(4,4),(0,0)), 'constant', constant_values=(0,0))\n",
    "print (train_dataset.shape)\n",
    "\n",
    "test_dataset=np.pad(test_dataset, ((0,0),(4,4),(4,4),(0,0)), 'constant', constant_values=(0,0))\n",
    "print (test_dataset.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FT the training and test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4495f5f515ed49f8a49f72503d74f7b8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=60000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/mcherukara/miniconda3/envs/gpu/lib/python3.6/site-packages/scipy/fftpack/basic.py:160: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  z[index] = x\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "da939bcdb02a41a4b3feda0a5cc45c56",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=10000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "(60000, 36, 36, 2)\n",
      "(10000, 36, 36, 2)\n"
     ]
    }
   ],
   "source": [
    "dims=train_dataset.shape\n",
    "ft_train=np.zeros((dims[0], 36, 36, 2), float)\n",
    "for i in tnrange(dims[0]):\n",
    "    ft_train[i,:,:,0]=np.abs(fftshift(fftn(train_dataset[i,:,:]))).squeeze()\n",
    "    ft_train[i,:,:,1]=np.angle(fftshift(fftn(train_dataset[i,:,:]))).squeeze()\n",
    "#    ft_train[i,:,:,1]=unwrap_phase(ft_train[i,:,:,1])\n",
    "\n",
    "dims=test_dataset.shape\n",
    "ft_test=np.zeros((dims[0], 36, 36, 2), float)\n",
    "for i in tqdm_notebook(range(dims[0])):\n",
    "    ft_test[i,:,:,0]=np.abs(fftshift(fftn(test_dataset[i,:,:]))).squeeze()\n",
    "    ft_test[i,:,:,1]=np.angle(fftshift(fftn(test_dataset[i,:,:]))).squeeze()\n",
    "#    ft_test[i,:,:,1]=unwrap_phase(ft_test[i,:,:,1])\n",
    "\n",
    "print (ft_train.shape)\n",
    "print (ft_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7ffabc0d6b38>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i=200\n",
    "plt.viridis()\n",
    "f,axarr=plt.subplots(1,2,figsize=(8, 6))\n",
    "axarr[0].imshow(np.abs(train_dataset[i].squeeze()))\n",
    "img=axarr[1].imshow(ft_train[i,:,:,1].squeeze())\n",
    "#from skimage.restoration import unwrap_phase\n",
    "#tmp=unwrap_phase(ft_train[i,:,:,1].squeeze())\n",
    "#img=axarr[1].imshow(tmp)\n",
    "f.colorbar(img, fraction=0.046, pad=0.04)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# O.K now try CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ModelMGPU(Model):\n",
    "    def __init__(self, ser_model, gpus):\n",
    "        pmodel = multi_gpu_model(ser_model, gpus)\n",
    "        self.__dict__.update(pmodel.__dict__)\n",
    "        self._smodel = ser_model\n",
    "\n",
    "    def __getattribute__(self, attrname):\n",
    "        '''Override load and save methods to be used from the serial-model. The\n",
    "        serial-model holds references to the weights in the multi-gpu model.\n",
    "        '''\n",
    "        # return Model.__getattribute__(self, attrname)\n",
    "        if 'load' in attrname or 'save' in attrname:\n",
    "            return getattr(self._smodel, attrname)\n",
    "\n",
    "        return super(ModelMGPU, self).__getattribute__(attrname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60000, 36, 36, 2)\n",
      "(60000, 36, 36, 2)\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "conv2d_1_input (InputLayer)     (None, 36, 36, 2)    0                                            \n",
      "__________________________________________________________________________________________________\n",
      "lambda_1 (Lambda)               (None, 36, 36, 2)    0           conv2d_1_input[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "lambda_2 (Lambda)               (None, 36, 36, 2)    0           conv2d_1_input[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "sequential_1 (Sequential)       (None, 10)           1522130     lambda_1[0][0]                   \n",
      "                                                                 lambda_2[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "dense_2 (Concatenate)           (None, 10)           0           sequential_1[1][0]               \n",
      "                                                                 sequential_1[2][0]               \n",
      "==================================================================================================\n",
      "Total params: 1,522,130\n",
      "Trainable params: 1,522,130\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n",
      "None\n",
      "Train on 54000 samples, validate on 6000 samples\n",
      "Epoch 1/10\n",
      "54000/54000 [==============================] - 6s 107us/step - loss: 0.7145 - acc: 0.7550 - val_loss: 0.1441 - val_acc: 0.9572\n",
      "\n",
      "Epoch 00001: saving model to ft_models/weights.01.hdf5\n",
      "Epoch 2/10\n",
      "54000/54000 [==============================] - 3s 50us/step - loss: 0.1505 - acc: 0.9541 - val_loss: 0.1025 - val_acc: 0.9700\n",
      "\n",
      "Epoch 00002: saving model to ft_models/weights.02.hdf5\n",
      "Epoch 3/10\n",
      "54000/54000 [==============================] - 3s 50us/step - loss: 0.0986 - acc: 0.9696 - val_loss: 0.0843 - val_acc: 0.9737\n",
      "\n",
      "Epoch 00003: saving model to ft_models/weights.03.hdf5\n",
      "Epoch 4/10\n",
      "54000/54000 [==============================] - 3s 50us/step - loss: 0.0768 - acc: 0.9762 - val_loss: 0.0880 - val_acc: 0.9745\n",
      "\n",
      "Epoch 00004: saving model to ft_models/weights.04.hdf5\n",
      "Epoch 5/10\n",
      "54000/54000 [==============================] - 3s 49us/step - loss: 0.0602 - acc: 0.9810 - val_loss: 0.0727 - val_acc: 0.9777\n",
      "\n",
      "Epoch 00005: saving model to ft_models/weights.05.hdf5\n",
      "Epoch 6/10\n",
      "54000/54000 [==============================] - 3s 49us/step - loss: 0.0466 - acc: 0.9851 - val_loss: 0.0726 - val_acc: 0.9793\n",
      "\n",
      "Epoch 00006: saving model to ft_models/weights.06.hdf5\n",
      "Epoch 7/10\n",
      "54000/54000 [==============================] - 3s 49us/step - loss: 0.0416 - acc: 0.9873 - val_loss: 0.0680 - val_acc: 0.9810\n",
      "\n",
      "Epoch 00007: saving model to ft_models/weights.07.hdf5\n",
      "Epoch 8/10\n",
      "54000/54000 [==============================] - 3s 49us/step - loss: 0.0361 - acc: 0.9889 - val_loss: 0.0716 - val_acc: 0.9812\n",
      "\n",
      "Epoch 00008: saving model to ft_models/weights.08.hdf5\n",
      "Epoch 9/10\n",
      "54000/54000 [==============================] - 3s 50us/step - loss: 0.0348 - acc: 0.9889 - val_loss: 0.0674 - val_acc: 0.9810\n",
      "\n",
      "Epoch 00009: saving model to ft_models/weights.09.hdf5\n",
      "Epoch 10/10\n",
      "54000/54000 [==============================] - 3s 49us/step - loss: 0.0352 - acc: 0.9891 - val_loss: 0.0623 - val_acc: 0.9822\n",
      "\n",
      "Epoch 00010: saving model to ft_models/weights.10.hdf5\n"
     ]
    }
   ],
   "source": [
    "dims=ft_train.shape\n",
    "print (dims)\n",
    "trainee=ft_train.reshape(dims[0],dims[1],dims[2],2)\n",
    "dims=test_dataset.shape\n",
    "testee=ft_test.reshape(dims[0],dims[1],dims[2],2)\n",
    "print (trainee.shape)\n",
    "\n",
    "w_size=3\n",
    "\n",
    "np.random.seed(123)\n",
    "model=Sequential()\n",
    "\n",
    "model.add(Conv2D(32,(w_size,w_size), activation='relu', input_shape=(36,36,2),\n",
    "                     data_format='channels_last', padding='same'))\n",
    "model.add(Conv2D(32,(w_size,w_size), activation='relu', padding='same'))\n",
    "model.add(MaxPool2D(pool_size=(2,2)))\n",
    "model.add(Conv2D(64,(w_size,w_size), activation='relu', padding='same'))\n",
    "model.add(Conv2D(64,(w_size,w_size), activation='relu', padding='same'))\n",
    "model.add(MaxPool2D(pool_size=(2,2)))\n",
    "model.add(Conv2D(128,(w_size,w_size), activation='relu', padding='same'))\n",
    "model.add(Conv2D(128,(w_size,w_size), activation='relu', padding='same'))\n",
    "model.add(MaxPool2D(pool_size=(2,2)))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(600, activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(10, activation='sigmoid')) \n",
    "\n",
    "parallel_model = ModelMGPU(model, gpus=num_GPU)\n",
    "parallel_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "\n",
    "#print (model.summary())\n",
    "print (parallel_model.summary())\n",
    "\n",
    "\n",
    "\n",
    "checkpoints=keras.callbacks.ModelCheckpoint('ft_models/weights.{epoch:02d}.hdf5', \n",
    "                                            monitor='val_loss', verbose=1, \n",
    "                                            save_best_only=False, \n",
    "                                            save_weights_only=False, \n",
    "                                            mode='auto', period=1)\n",
    "\n",
    "history=parallel_model.fit(trainee, train_labels, batch_size=256, verbose=1, epochs=10, \n",
    "                  validation_split = 0.1, callbacks=[checkpoints])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist=history\n",
    "epochs=np.asarray(history.epoch)+1\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "plt.style.use('seaborn-white')\n",
    "matplotlib.rc('font',family='Times New Roman')\n",
    "matplotlib.rcParams['font.size'] = 20\n",
    "\n",
    "f, axarr = plt.subplots(2, sharex=True, figsize=(8, 6))\n",
    "\n",
    "axarr[0].set(ylabel='Loss')\n",
    "axarr[0].plot(epochs,hist.history['loss'], 'C3o', label='Training')\n",
    "axarr[0].plot(epochs,hist.history['val_loss'], 'C3-', label='Validation')\n",
    "axarr[0].grid()\n",
    "axarr[0].legend(loc='center right', bbox_to_anchor=(1.0, 0.5))\n",
    "\n",
    "\n",
    "axarr[1].plot(epochs,hist.history['acc'], 'C0o', label='Training')\n",
    "axarr[1].plot(epochs,hist.history['val_acc'], 'C0-', label='Validation')\n",
    "plt.legend(loc='center right', bbox_to_anchor=(1.0, 0.5))\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.tight_layout()\n",
    "plt.grid()\n",
    "plt.tick_params(which='both', width=2)\n",
    "plt.tick_params(which='major', length=7)\n",
    "plt.tick_params(which='minor', length=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 9728/10000 [============================>.] - ETA: 0s[0.06683168837108242, 0.9811]\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Model, load_model\n",
    "model=load_model('ft_models/weights.06.hdf5') #Numbering starts from 0\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "score=model.evaluate(testee, test_labels, verbose=1)\n",
    "print (score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds=(model.predict(testee))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "i=100\n",
    "f,axarr=plt.subplots(1,2,figsize=(8, 6))\n",
    "axarr[0].imshow(test_dataset[i].squeeze(),cmap='viridis')\n",
    "img=axarr[1].imshow(testee[i,:,:,1].squeeze(), cmap='viridis')\n",
    "plt.colorbar(img, fraction=0.046, pad=0.04)\n",
    "print (np.argmax(preds[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "default_view": {},
   "name": "1_notmnist.ipynb",
   "provenance": [],
   "version": "0.3.2",
   "views": {}
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}