--- a
+++ b/model-code.ipynb
@@ -0,0 +1,836 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['train', 'test', 'val', '.DS_Store']\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd \n",
+    "import cv2                 \n",
+    "import numpy as np         \n",
+    "import os                  \n",
+    "from random import shuffle\n",
+    "from tqdm import tqdm  \n",
+    "import scipy\n",
+    "import skimage\n",
+    "from skimage.transform import resize\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "print(os.listdir(\"cancer/\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Cancer', 'Normal']\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(os.listdir(\"cancer/train\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TRAIN_DIR = \"cancer/train/\"\n",
+    "TEST_DIR =  \"cancer/test/\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Preprocessing \n",
+    "def get_label(Dir):\n",
+    "    for nextdir in os.listdir(Dir):\n",
+    "        if not nextdir.startswith('.'):\n",
+    "            if nextdir in ['NORMAL']:\n",
+    "                label = 0\n",
+    "            elif nextdir in ['CANCER']:\n",
+    "                label = 1\n",
+    "            else:\n",
+    "                label = 2\n",
+    "    return nextdir, label"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def preprocessing_data(Dir):\n",
+    "    X = []\n",
+    "    y = []\n",
+    "    \n",
+    "    for nextdir in os.listdir(Dir):\n",
+    "        nextdir, label = get_label(Dir)\n",
+    "        temp = Dir + nextdir\n",
+    "        \n",
+    "        for image_filename in tqdm(os.listdir(temp)):\n",
+    "            path = os.path.join(temp + '/' , image_filename)\n",
+    "            img = cv2.imread(path,cv2.IMREAD_GRAYSCALE)\n",
+    "            if img is not None:\n",
+    "                img = skimage.transform.resize(img, (150, 150, 3))\n",
+    "                img = np.asarray(img)\n",
+    "                X.append(img)\n",
+    "                y.append(label)\n",
+    "            \n",
+    "    X = np.asarray(X)\n",
+    "    y = np.asarray(y)\n",
+    "    \n",
+    "    return X,y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    " #X_train, y_train = preprocessing_data(TRAIN_DIR)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_data(Dir):\n",
+    "    X = []\n",
+    "    y = []\n",
+    "    for nextDir in os.listdir(Dir):\n",
+    "        if not nextDir.startswith('.'):\n",
+    "            if nextDir in ['NORMAL']:\n",
+    "                label = 0\n",
+    "            elif nextDir in ['CANCER']:\n",
+    "                label = 1\n",
+    "            else:\n",
+    "                label = 2\n",
+    "                \n",
+    "            temp = Dir + nextDir\n",
+    "                \n",
+    "            for file in tqdm(os.listdir(temp)):\n",
+    "                img = cv2.imread(temp + '/' + file)\n",
+    "                if img is not None:\n",
+    "                    img = skimage.transform.resize(img, (150, 150, 3))\n",
+    "                    #img_file = scipy.misc.imresize(arr=img_file, size=(150, 150, 3))\n",
+    "                    img = np.asarray(img)\n",
+    "                    X.append(img)\n",
+    "                    y.append(label)\n",
+    "                    \n",
+    "    X = np.asarray(X)\n",
+    "    y = np.asarray(y)\n",
+    "    return X,y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 2478/2478 [00:27<00:00, 23.64it/s] \n",
+      "100%|██████████| 2483/2483 [00:39<00:00, 63.38it/s] \n"
+     ]
+    }
+   ],
+   "source": [
+    "X_train, y_train = get_data(TRAIN_DIR)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 620/620 [00:17<00:00, 35.22it/s]\n",
+      "100%|██████████| 620/620 [00:15<00:00, 40.49it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "X_test , y_test = get_data(TEST_DIR)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(4961, 150, 150, 3) \n",
+      " (1240, 150, 150, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(X_train.shape,'\\n',X_test.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(4961,) \n",
+      " (1240,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(y_train.shape,'\\n',y_test.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from keras.utils.np_utils import to_categorical\n",
+    "\n",
+    "y_train = to_categorical(y_train, 2)\n",
+    "y_test = to_categorical(y_test, 2)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(4961,) \n",
+      " (1240,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(y_train.shape,'\\n',y_test.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "Pimages = os.listdir(TRAIN_DIR + \"CANCER\")\n",
+    "Nimages = os.listdir(TRAIN_DIR + \"NORMAL\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(Left) - No CANCER Vs (Right) - CANCER\n",
+      "-----------------------------------------------------------------------------------------------------------------------------------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(Left) - No CANCER Vs (Right) - CANCER\n",
+      "-----------------------------------------------------------------------------------------------------------------------------------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(Left) - No CANCER Vs (Right) - CANCER\n",
+      "-----------------------------------------------------------------------------------------------------------------------------------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(Left) - No CANCER Vs (Right) - CANCER\n",
+      "-----------------------------------------------------------------------------------------------------------------------------------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(Left) - No CANCER Vs (Right) - CANCER\n",
+      "-----------------------------------------------------------------------------------------------------------------------------------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "def plotter(i):\n",
+    "    imagep1 = cv2.imread(TRAIN_DIR+\"CANCER/\"+Pimages[i])\n",
+    "    imagep1 = skimage.transform.resize(imagep1, (150, 150, 3) , mode = 'reflect')\n",
+    "    imagen1 = cv2.imread(TRAIN_DIR+\"NORMAL/\"+Nimages[i])\n",
+    "    imagen1 = skimage.transform.resize(imagen1, (150, 150, 3))\n",
+    "    pair = np.concatenate((imagen1, imagep1), axis=1)\n",
+    "    print(\"(Left) - No CANCER Vs (Right) - CANCER\")\n",
+    "    print(\"-----------------------------------------------------------------------------------------------------------------------------------\")\n",
+    "    plt.figure(figsize=(10,5))\n",
+    "    plt.imshow(pair)\n",
+    "    plt.show()\n",
+    "for i in range(0,5):\n",
+    "    plotter(i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn import metrics\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "\n",
+    "#function\n",
+    "def train_test_rmse(x,y):\n",
+    "    x = Iris_data[x]\n",
+    "    y = Iris_data[y]\n",
+    "    X_train, X_test, y_train, y_test = train_test_split(x, y, test_size = 0.2,random_state=123)\n",
+    "    linreg = LinearRegression()\n",
+    "    linreg.fit(X_train, y_train)\n",
+    "    y_pred = linreg.predict(X_test)\n",
+    "    print(accuracy_score(y_test, y_pred))  # or you can save it in variable and return it \n",
+    "    return np.sqrt(metrics.mean_squared_error(y_test, y_pred))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x7f6d256ef9e8>"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import seaborn as sns\n",
+    "count = y_train.sum(axis = 0)\n",
+    "sns.countplot(x = count)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/neuzan/Programs/anaconda3/envs/DeepL/lib/python3.6/site-packages/keras/callbacks.py:1065: UserWarning: `epsilon` argument is deprecated and will be removed, use `min_delta` instead.\n",
+      "  warnings.warn('`epsilon` argument is deprecated and '\n"
+     ]
+    }
+   ],
+   "source": [
+    "from keras.callbacks import ReduceLROnPlateau , ModelCheckpoint\n",
+    "lr_reduce = ReduceLROnPlateau(monitor='val_acc', factor=0.1, epsilon=0.0001, patience=1, verbose=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filepath=\"weights.hdf5\"\n",
+    "checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from keras.models import Sequential\n",
+    "from keras.layers import Dense , Activation\n",
+    "from keras.layers import Dropout\n",
+    "from keras.layers import Flatten\n",
+    "from keras.constraints import maxnorm\n",
+    "from keras.optimizers import SGD , RMSprop\n",
+    "from keras.layers import Conv2D , BatchNormalization\n",
+    "from keras.layers import MaxPooling2D\n",
+    "from keras.utils import np_utils\n",
+    "from keras import backend as K\n",
+    "K.set_image_dim_ordering('th')\n",
+    "from sklearn.model_selection import GridSearchCV\n",
+    "from keras.wrappers.scikit_learn import KerasClassifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#X_train=X_train.reshape(5216,3,150,150)\n",
+    "#X_test=X_test.reshape(624,3,150,150)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "_________________________________________________________________\n",
+      "Layer (type)                 Output Shape              Param #   \n",
+      "=================================================================\n",
+      "conv2d_1 (Conv2D)            (None, 16, 150, 3)        21616     \n",
+      "_________________________________________________________________\n",
+      "conv2d_2 (Conv2D)            (None, 16, 150, 3)        2320      \n",
+      "_________________________________________________________________\n",
+      "conv2d_3 (Conv2D)            (None, 32, 150, 3)        4640      \n",
+      "_________________________________________________________________\n",
+      "conv2d_4 (Conv2D)            (None, 32, 150, 3)        9248      \n",
+      "_________________________________________________________________\n",
+      "conv2d_5 (Conv2D)            (None, 64, 150, 3)        18496     \n",
+      "_________________________________________________________________\n",
+      "conv2d_6 (Conv2D)            (None, 64, 150, 3)        36928     \n",
+      "_________________________________________________________________\n",
+      "max_pooling2d_1 (MaxPooling2 (None, 64, 75, 1)         0         \n",
+      "_________________________________________________________________\n",
+      "flatten_1 (Flatten)          (None, 4800)              0         \n",
+      "_________________________________________________________________\n",
+      "dense_1 (Dense)              (None, 64)                307264    \n",
+      "_________________________________________________________________\n",
+      "dropout_1 (Dropout)          (None, 64)                0         \n",
+      "_________________________________________________________________\n",
+      "dense_2 (Dense)              (None, 2)                 130       \n",
+      "=================================================================\n",
+      "Total params: 400,642\n",
+      "Trainable params: 400,642\n",
+      "Non-trainable params: 0\n",
+      "_________________________________________________________________\n",
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = Sequential()\n",
+    "model.add(Conv2D(16, (3, 3), activation='relu', padding=\"same\", input_shape=(150,150,3)))\n",
+    "model.add(Conv2D(16, (3, 3), padding=\"same\", activation='relu'))\n",
+    "\n",
+    "model.add(Conv2D(32, (3, 3), activation='relu', padding=\"same\"))\n",
+    "model.add(Conv2D(32, (3, 3), padding=\"same\", activation='relu'))\n",
+    "\n",
+    "model.add(Conv2D(64, (3, 3), activation='relu', padding=\"same\"))\n",
+    "model.add(Conv2D(64, (3, 3), padding=\"same\", activation='relu'))\n",
+    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
+    "\n",
+    "\n",
+    "model.add(Flatten())\n",
+    "\n",
+    "model.add(Dense(64, activation='relu'))\n",
+    "model.add(Dropout(0.2))\n",
+    "model.add(Dense(2 , activation='sigmoid'))\n",
+    "\n",
+    "model.compile(loss='binary_crossentropy',\n",
+    "                  optimizer=RMSprop(lr=0.00005),\n",
+    "                  metrics=['accuracy'])\n",
+    "\n",
+    "print(model.summary())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 256\n",
+    "epochs = 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train on 5216 samples, validate on 624 samples\n",
+      "Epoch 1/10\n",
+      "5216/5216 [==============================] - 12s 2ms/step - loss: 0.5063 - acc: 0.7597 - val_loss: 0.4808 - val_acc: 0.7780\n",
+      "\n",
+      "Epoch 00001: val_acc improved from -inf to 0.77804, saving model to weights.hdf5\n",
+      "Epoch 2/10\n",
+      "5216/5216 [==============================] - 6s 1ms/step - loss: 0.2925 - acc: 0.8792 - val_loss: 0.6008 - val_acc: 0.7252\n",
+      "\n",
+      "Epoch 00002: ReduceLROnPlateau reducing learning rate to 4.999999873689376e-06.\n",
+      "\n",
+      "Epoch 00002: val_acc did not improve from 0.77804\n",
+      "Epoch 3/10\n",
+      "5216/5216 [==============================] - 6s 1ms/step - loss: 0.2312 - acc: 0.9042 - val_loss: 0.5019 - val_acc: 0.7780\n",
+      "\n",
+      "Epoch 00003: ReduceLROnPlateau reducing learning rate to 4.999999873689376e-07.\n",
+      "\n",
+      "Epoch 00003: val_acc did not improve from 0.77804\n",
+      "Epoch 4/10\n",
+      "5216/5216 [==============================] - 6s 1ms/step - loss: 0.2249 - acc: 0.9077 - val_loss: 0.4912 - val_acc: 0.7821\n",
+      "\n",
+      "Epoch 00004: val_acc improved from 0.77804 to 0.78205, saving model to weights.hdf5\n",
+      "Epoch 5/10\n",
+      "5216/5216 [==============================] - 7s 1ms/step - loss: 0.2243 - acc: 0.9097 - val_loss: 0.4968 - val_acc: 0.7796\n",
+      "\n",
+      "Epoch 00005: ReduceLROnPlateau reducing learning rate to 4.999999987376214e-08.\n",
+      "\n",
+      "Epoch 00005: val_acc did not improve from 0.78205\n",
+      "Epoch 6/10\n",
+      "5216/5216 [==============================] - 7s 1ms/step - loss: 0.2251 - acc: 0.9078 - val_loss: 0.4975 - val_acc: 0.7796\n",
+      "\n",
+      "Epoch 00006: ReduceLROnPlateau reducing learning rate to 5.000000058430488e-09.\n",
+      "\n",
+      "Epoch 00006: val_acc did not improve from 0.78205\n",
+      "Epoch 7/10\n",
+      "5216/5216 [==============================] - 7s 1ms/step - loss: 0.2224 - acc: 0.9094 - val_loss: 0.4974 - val_acc: 0.7796\n",
+      "\n",
+      "Epoch 00007: ReduceLROnPlateau reducing learning rate to 4.999999969612646e-10.\n",
+      "\n",
+      "Epoch 00007: val_acc did not improve from 0.78205\n",
+      "Epoch 8/10\n",
+      "5216/5216 [==============================] - 7s 1ms/step - loss: 0.2255 - acc: 0.9078 - val_loss: 0.4974 - val_acc: 0.7796\n",
+      "\n",
+      "Epoch 00008: ReduceLROnPlateau reducing learning rate to 4.999999858590343e-11.\n",
+      "\n",
+      "Epoch 00008: val_acc did not improve from 0.78205\n",
+      "Epoch 9/10\n",
+      "5216/5216 [==============================] - 7s 1ms/step - loss: 0.2243 - acc: 0.9085 - val_loss: 0.4974 - val_acc: 0.7796\n",
+      "\n",
+      "Epoch 00009: ReduceLROnPlateau reducing learning rate to 4.999999719812465e-12.\n",
+      "\n",
+      "Epoch 00009: val_acc did not improve from 0.78205\n",
+      "Epoch 10/10\n",
+      "5216/5216 [==============================] - 7s 1ms/step - loss: 0.2242 - acc: 0.9088 - val_loss: 0.4974 - val_acc: 0.7796\n",
+      "\n",
+      "Epoch 00010: ReduceLROnPlateau reducing learning rate to 4.999999546340118e-13.\n",
+      "\n",
+      "Epoch 00010: val_acc did not improve from 0.78205\n"
+     ]
+    }
+   ],
+   "source": [
+    "history = model.fit(X_train, y_train, validation_data = (X_test , y_test) ,callbacks=[lr_reduce,checkpoint] ,\n",
+    "          epochs=epochs)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.save('mymodel.h5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from keras.models import load_model\n",
+    "\n",
+    "\n",
+    "plt.plot(history.history['acc'])\n",
+    "plt.plot(history.history['val_acc'])\n",
+    "plt.title('model accuracy')\n",
+    "plt.ylabel('accuracy')\n",
+    "plt.xlabel('epoch')\n",
+    "plt.legend(['train', 'test'], loc='upper left')\n",
+    "plt.show()\n",
+    "# summarize history for loss\n",
+    "plt.plot(history.history['loss'])\n",
+    "plt.plot(history.history['val_loss'])\n",
+    "plt.title('model loss')\n",
+    "plt.ylabel('loss')\n",
+    "plt.xlabel('epoch')\n",
+    "plt.legend(['train', 'test'], loc='upper left')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import confusion_matrix\n",
+    "pred = model.predict(X_test)\n",
+    "pred = np.argmax(pred,axis = 1) \n",
+    "y_true = np.argmax(y_test,axis = 1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAT0AAAFACAYAAADOJ6uCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAEq9JREFUeJzt3Xm0lXW9gPHnezgyyHwYhADFAcVhpQWaqXW75oDmyjIzSCtTc0gto1vqWl2VrFXdy13XbrduoVKuNL2WVmpqjqSSBmSKOJCoJIMyHEDgqByG3/3jvOABGTZe3rP38fd81jrrvPvd797vd68Fz3rfPZ1IKSFJuair9gCS1JaMnqSsGD1JWTF6krJi9CRlxehJyorRk5QVoycpK0ZPUlbqqz1Aa71690kDBg2p9hiqUWv89JC2YOH8OSxfuiQq2bamojdg0BAm3PpAtcdQjVq2qrnaI6hGjR19bMXbenorKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZaW+2gPk6vuXXsijk+6hd5++/OKOyQAsX7aUK752Jq/Om8OAQUMYd9VEuvfsxcoVy/nON85l4fy5rF27hs+ccT7Hf+rUKj8ClemgQT3YpUcnVq1Zx6TnGwHYb0B3duneiZQSTc1r+dvc11izLgHQo3M97x3Ug/q6AOChWY0UV2kTpR7pRcSoiJgZEbMi4pIy99XeHHfSGP79mps3WnfDhB8y4oMf5lf3TGXEBz/MDROuAuC3N1zD0D33ZuJtD/HDX97GT35wGaubm6sxttrIy0vf4LGXlm60btHKVUx6fjGTZjWysnkNw/p3BSCA9w/uyfR5y5n0fCOTX1xi8LaitOhFRAfgx8BxwH7AmIjYr6z9tTcHHnwY3Xv23mjd5PvvZNQnRgMw6hOjeeS+OwGICF5vWklKiTeamujRszcd6j1Ifzdb8vpqmtduXK5FK5tZv2bp66vpslMHAPp178jyN9ew/M01AKxea/G2psz/OYcAs1JKLwJExE3AicAzJe6zXVvauIg+/QcA0Kf/AJYuWQzASaeexaXnncZJH9qfN5pWcvl/XkNdnU/H5mzX3l2Y/9qbAHTrWE8CDh3am471dcxf9iazFjdVd8AaVub/nEHAnFaX5xbrNhIRZ0fEtIiYtmxpY4njtF9THnmQYfsewK0PP801v5vEVd++mKaVy6s9lqpkWL+upARzl7VELwIauu7E43OWMfmFRgb07ETfrh2rPGXtKjN6sZl1bzvuTilNSCmNTCmN7NW7T4nj1L7effrRuPBVABoXvkrvhr4A3HXrr/jQMScQEQzebQ8GDt6Vl198vpqjqkqG9OrMLj068ficZRvWvbF6HY1NLafDaxMsXLGKnl18+mNLyozeXGBIq8uDgfkl7q/dO/zI47j7dzcBcPfvbuLwjx4PQP+Bg3j80YcAWLJ4IXNemsXAwUOrNaaqpF+3juzVrxtTZi+l9dN2i1asokfnejpEy5FGn64dWbFqbdXmrHWRUjlPekZEPfB34KPAPGAq8NmU0tNbus3wAw5KE259oJR5as24sV/iiSmTeW1pIw19+vHFCy/hiKOO54qLzmDBK/PYZeAgxv3w5/To1ZvFC17he5deQOOiBZASn/3SVznmxFOq/RDa3LJV+bxi/f4hPenbtSMd6+tYtWYdMxesZFi/rtRF0Lx2HdDyYsb0+S1Pcwzu1Zm9+rW8mrtwxSqeeXVl1WavhrGjj2XW009u7uzybUqLHkBEHA9cBXQAJqaUvru17XOKnrZfTtHT9tme6JV64p9SuhO4s8x9SNL28H0PkrJi9CRlxehJyorRk5QVoycpK0ZPUlaMnqSsGD1JWTF6krJi9CRlxehJyorRk5QVoycpK0ZPUlaMnqSsGD1JWTF6krJi9CRlxehJyorRk5QVoycpK0ZPUlaMnqSsGD1JWTF6krJi9CRlxehJyorRk5QVoycpK0ZPUlaMnqSsGD1JWTF6krJi9CRlxehJyorRk5QVoycpK0ZPUlaMnqSsGD1JWTF6krJSv6UrImIFkNZfLH6nYjmllHqUPJsk7XBbjF5KqXtbDiJJbaGi09uIOCIivlgs942I3csdS5LKsc3oRcTlwMXApcWqjsD1ZQ4lSWWp5Ejvk8DHgSaAlNJ8wFNfSe1SJdFrTiklihc1IqJruSNJUnkqid7NEfEzoFdEfAm4D7i63LEkqRxbfPV2vZTS+Ig4GlgO7A1cllK6t/TJJKkE24xe4SmgCy2nuE+VN44klauSV2/PAqYAJwEnA49FxBllDyZJZajkSO8bwPtSSo0AEdEH+DMwsczBJKkMlbyQMRdY0eryCmBOOeNIUrm29tnbscXiPOAvEfF7Wp7TO5GW011Jane2dnq7/g3ILxQ/6/2+vHEkqVxb+8KBcW05iCS1hW2+kBER/YBvAvsDndevTykdWeJcklSKSl7IuAF4DtgdGAfMBqaWOJMklaaS6PVJKV0LrE4p/SmldAZwaMlzSVIpKnmf3uri9ysR8TFgPjC4vJEkqTyVRO87EdET+DrwI6AH8LVSp5KkklTyhQN3FIuvAf9c7jiSVK6tvTn5R7z1h4HeJqX0lR09TNdO9RyyR8OOvlu9S/Q++IJqj6AateqlVyredmtHetP+/6NIUm3Z2puTr2vLQSSpLfjHviVlxehJyorRk5SVSr45ee+IuD8iZhSX3xsR3yp/NEna8So50rualj/0vRogpTQdGF3mUJJUlkqit3NKadMvDV1TxjCSVLZKorc4IvbkrT/2fTJQ+TsBJamGVPLZ2/OBCcDwiJgHvAScVupUklSSSj57+yJwVER0BepSSiu2dRtJqlWVfHPyZZtcBiCl9O2SZpKk0lRyetvUarkzcALwbDnjSFK5Kjm9/Y/WlyNiPHBbaRNJUoneyScydgb22NGDSFJbqOQ5vad463v1OgD9AJ/Pk9QuVfKc3gmtltcAC1JKvjlZUru01ehFRB3wh5TSAW00jySVaqvP6aWU1gFPRsSubTSPJJWqktPbgcDTETGFVm9fSSl9vLSpJKkklURvXOlTSFIbqSR6x6eULm69IiJ+APypnJEkqTyVvE/v6M2sO25HDyJJbWFrf/f2PODLwB4RMb3VVd2ByWUPJkll2Nrp7a+Au4DvAZe0Wr8ipbSk1KkkqSRb+7u3rwGvAWPabhxJKpd/DU1SVoyepKwYPUlZMXqSsmL0JGXF6EnKitGTlBWjJykrRk9SVoyepKwYPUlZMXqSsmL0JGXF6EnKitGTlBWjJykrRk9SVoyepKwYPUlZMXqSsmL0JGXF6EnKitGTlBWjJykrRk9SVoyepKwYPUlZMXqSsmL0JGXF6EnKitGTlBWjJykrRk9SVoyepKwYPUlZMXqSsmL0JGWlvtoDCM456wzuuvMO+vXvz1+fmAHALb/5Nd+98gqee/ZZHv7zFEaMHFnlKdWWOnWs575rL6Jjx3rqO3Tgt/f9je/89E7uu/YiunXtDED/hu5MmzGbU8ZeTa/uXfjZFaex++C+rGpezTlX3MAzL7xS5UdRm0qLXkRMBE4AFqaUDihrP+8Gn/vC6Zz75Qs464zPb1i3//4HcNPNt3LBl8+p4mSqllXNaxh19n/R9EYz9fV1PDBxLPdMfoajzrxqwzY3jj+L2ydNB+CbZx7LkzPn8pmvX83eQ3fhqktO4fhzf1St8Wtamae3vwBGlXj/7xpHfOjDNDQ0bLRu+L77svc++1RpItWCpjeaAdipvgP19R1IKW24rtvOnfing/fm9gdbojd8jwFMmjITgL/PXsBu72mgf0P3th+6HSgteimlh4AlZd2/9G5XVxc8dtMlvHz/93ngseeYOuMfG677+JEHMmnKTFY0vQnAU3+fx4kfPQiAkfvvxq4DGxi0S6+qzF3rqv5CRkScHRHTImLaosWLqj2OVDPWrUscOvr77HXstxh5wG7st+fADdedMmoEN9/91w2Xx//8Xnp135nHbrqE80b/E0/OnMuateuqMXbNq/oLGSmlCcAEgBEjRqZtbC5l57WVb/DQtOc55rD9eOaFV2jo2ZWR+w/lM2Ov3rDNiqY3OeeK6zdcfu4P45g9r7Ea49a8qh/pSXq7vr270bNbFwA6d9qJIz+wDzNnLwDgpKPfx10Pz2BV85oN2/fs1oWd6jsA8MVPHsYjj8/acOqrjVX9SE/w+dPG8PCfJrF48WL2HDqYf71sHL0bGhh70YUsXrSIk078GO898CBuv/OP1R5VbWRA3x5c/e3P0aGujrq64JZ7H+euh1vezvTpY0cw/uf3bLT98D0GcM2Vn2Pt2nU89+KrnDvuhmqM3S5E61eEdugdR9wIfAToCywALk8pXbu124wYMTJN/su0UuZR+9f74AuqPYJq1KqZN7Pu9YVRybalHemllMaUdd+S9E75nJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUFaMnKStGT1JWjJ6krBg9SVkxepKyYvQkZcXoScqK0ZOUlUgpVXuGDSJiEfCPas9RQ/oCi6s9hGqS/zY2tltKqV8lG9ZU9LSxiJiWUhpZ7TlUe/y38c55eispK0ZPUlaMXm2bUO0BVLP8t/EO+ZyepKx4pCcpK0ZPUlaMXg2KiFERMTMiZkXEJdWeR7UjIiZGxMKImFHtWdoro1djIqID8GPgOGA/YExE7FfdqVRDfgGMqvYQ7ZnRqz2HALNSSi+mlJqBm4ATqzyTakRK6SFgSbXnaM+MXu0ZBMxpdXlusU7SDmD0ak9sZp3vK5J2EKNXe+YCQ1pdHgzMr9Is0ruO0as9U4FhEbF7RHQERgO3VXkm6V3D6NWYlNIa4ALgj8CzwM0ppaerO5VqRUTcCDwK7BMRcyPizGrP1N74MTRJWfFIT1JWjJ6krBg9SVkxepKyYvQkZcXoqU1ExMri93si4jfb2PaiiNh5O+//IxFxR6XrN9nm9Ij47+3c3+yI6Ls9t1FtMHp6x4pvhNkuKaX5KaWTt7HZRcB2RU+qlNHT20TE0Ih4LiKui4jpEfGb9UdexRHOZRHxCPDpiNgzIu6OiL9GxMMRMbzYbveIeDQipkbElZvc94xiuUNEjI+Ip4r9XBgRXwHeAzwYEQ8W2x1T3NfjEfHriOhWrB9VzPkIcFIFj+uQiPhzRPyt+L1Pq6uHFI9jZkRc3uo2p0XElIh4IiJ+9k5CrxqTUvLHn41+gKG0fMnB4cXlicC/FMuzgW+22vZ+YFix/AHggWL5NuDzxfL5wMpW9z2jWD4PuAWoLy43tNpH32K5L/AQ0LW4fDFwGdCZlm+jGUbLlzTcDNyxmcfykfXrgR6t9nUUcEuxfDrwCtAH6ALMAEYC+wK3AzsV2/2k1WPaMKM/7eun/h10UnmYk1KaXCxfD3wFGF9c/l+A4ojrMODXERu+HKZT8ftw4FPF8i+BH2xmH0cBP00tH70jpbS574k7lJYvU51c7KMjLR/DGg68lFJ6vpjleuDsbTymnsB1ETGMlqjv1Oq6e1NKjcV93QocAawBRgBTi313ARZuYx+qcUZPW7Lp5xNbX24qftcBy1JKB1V4H5uKCre5N6U0ZqOVEQdVcNtNXQk8mFL6ZEQMBSa1um5zjzeA61JKl27nflTDfE5PW7JrRHywWB4DPLLpBiml5cBLEfFpgGhxYHH1ZFq+IQbg1C3s4x7g3IioL27fUKxfAXQvlh8DDo+IvYptdo6IvYHngN0jYs9WM25LT2BesXz6JtcdHRENEdEF+EQx//3AyRHRf/18EbFbBftRDTN62pJngS9ExHSgAfifLWx3KnBmRDwJPM1bX23/VeD8iJhKS2w25xrgZWB6cfvPFusnAHdFxIMppUW0BOrGYpbHgOEppTdpOZ39Q/FCxj8qeEz/BnwvIiYDm74g8Qgtp+FP0PJc37SU0jPAt4B7in3fCwysYD+qYX7Lit6mOPW7I6V0QJVHkXY4j/QkZcUjPUlZ8UhPUlaMnqSsGD1JWTF6krJi9CRl5f8Abk1D5KvCMagAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "CM = confusion_matrix(y_true, pred)\n",
+    "from mlxtend.plotting import plot_confusion_matrix\n",
+    "fig, ax = plot_confusion_matrix(conf_mat=CM ,  figsize=(5, 5))\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.7504950495049505"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#PRECISION = (TP/(TP+FP))\n",
+    "379/(379+126)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9717948717948718"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#RECALL = (TP/(TP+FN))\n",
+    "379 / (379 + 11)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.780448717948718"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#ACCURACY = (TP+TN)/(TP+TN+FP+FN)\n",
+    "(379+108)/(379+108+126+11)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "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.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}