arabic-font-recognition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.pyplot import imshow\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.pylab as plt\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "import numpy as np\n",
    "import PIL\n",
    "from PIL import ImageFilter\n",
    "import cv2\n",
    "import itertools\n",
    "import random\n",
    "import keras\n",
    "from keras import utils as np_utils\n",
    "import tensorflow as tf\n",
    "import imutils\n",
    "from imutils import paths\n",
    "import os\n",
    "from keras import optimizers\n",
    "from tensorflow.keras.utils import img_to_array\n",
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from keras import callbacks\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Flatten, BatchNormalization\n",
    "from keras.layers import Conv2D, MaxPooling2D , UpSampling2D ,Conv2DTranspose, Conv1D, MaxPooling1D, UpSampling1D\n",
    "from keras import backend as K\n",
    "import pandas as pd\n",
    "# %matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pil_image(img_path):\n",
    "    # convert image into gray scale\n",
    "    pil_im =PIL.Image.open(img_path).convert('L')\n",
    "    # resize image 105x105\n",
    "    pil_im=pil_im.resize((105,105))\n",
    "    #imshow(np.asarray(pil_im))\n",
    "    return pil_im"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Augumentation Steps\n",
    "1) Noise 2) Blur 3) Perpective Rotation 4) Shading 5) Variable Character Spacing 6) Variable Aspect Ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def noise_image(pil_im):\n",
    "    # Adding Noise to image\n",
    "    img_array = np.asarray(pil_im)\n",
    "    mean = 0.0   # some constant\n",
    "    std = 5   # some constant (standard deviation)\n",
    "    noisy_img = img_array + np.random.normal(mean, std, img_array.shape)\n",
    "    noisy_img_clipped = np.clip(noisy_img, 0, 255)\n",
    "    noise_img = PIL.Image.fromarray(np.uint8(noisy_img_clipped)) # output\n",
    "    #imshow((noisy_img_clipped ).astype(np.uint8))\n",
    "    noise_img=noise_img.resize((105,105))\n",
    "    return noise_img\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def blur_image(pil_im):\n",
    "    #Adding Blur to image \n",
    "    blur_img = pil_im.filter(ImageFilter.GaussianBlur(radius=3)) # ouput\n",
    "    #imshow(blur_img)\n",
    "    blur_img=blur_img.resize((105,105))\n",
    "    return blur_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def affine_rotation(img):\n",
    "    \n",
    "    #img=cv2.imread(img_path,0)\n",
    "    rows, columns = img.shape\n",
    "\n",
    "    point1 = np.float32([[10, 10], [30, 10], [10, 30]])\n",
    "    point2 = np.float32([[20, 15], [40, 10], [20, 40]])\n",
    "\n",
    "    A = cv2.getAffineTransform(point1, point2)\n",
    "\n",
    "    output = cv2.warpAffine(img, A, (columns, rows))\n",
    "    affine_img = PIL.Image.fromarray(np.uint8(output)) # affine rotated output\n",
    "    #imshow(output)\n",
    "    affine_img=affine_img.resize((105,105))\n",
    "    return affine_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_fill(image):\n",
    "    #image=cv2.imread(img_path,0)\n",
    "    laplacian = cv2.Laplacian(image,cv2.CV_64F)\n",
    "    laplacian = cv2.resize(laplacian, (105, 105))\n",
    "    return laplacian"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = \"ARABIC_dataset\"\n",
    "data=[]\n",
    "labels=[]\n",
    "imagePaths = sorted(list(paths.list_images(data_path)))\n",
    "random.seed(42)\n",
    "random.shuffle(imagePaths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_label(label):\n",
    "    if label == 'Diwani':\n",
    "        return 0\n",
    "    elif label == 'Kufi':\n",
    "        return 1\n",
    "    elif label == 'Maghribi':\n",
    "        return 2\n",
    "    elif label == 'Mohakek':\n",
    "        return 3\n",
    "    elif label == 'Parsi':\n",
    "        return 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['blur', 'noise', 'affine', 'gradient']\n",
      "466\n"
     ]
    }
   ],
   "source": [
    "augument=[\"blur\",\"noise\",\"affine\",\"gradient\"]\n",
    "a=itertools.combinations(augument, 4)\n",
    "\n",
    "for i in list(a): \n",
    "    print(list(i))\n",
    "\n",
    "print(len(imagePaths))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Diwani'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imagePaths[0].split(os.path.sep)[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Augment Function for Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7456\n"
     ]
    }
   ],
   "source": [
    "counter=0\n",
    "for imagePath in imagePaths:\n",
    "    label = imagePath.split(os.path.sep)[-2]\n",
    "    label = conv_label(label)\n",
    "    pil_img = pil_image(imagePath)\n",
    "    #imshow(pil_img)\n",
    "    \n",
    "    # Adding original image\n",
    "    org_img = img_to_array(pil_img)\n",
    "    #print(org_img.shape)\n",
    "    data.append(org_img)\n",
    "    labels.append(label)\n",
    "    \n",
    "    augument=[\"noise\",\"blur\",\"affine\",\"gradient\"]\n",
    "    for l in range(0,len(augument)):\n",
    "    \n",
    "        a=itertools.combinations(augument, l+1)\n",
    "\n",
    "        for i in list(a): \n",
    "            combinations=list(i)\n",
    "            #print(len(combinations))\n",
    "            temp_img = pil_img\n",
    "            for j in combinations:\n",
    "            \n",
    "                if j == 'noise':\n",
    "                    # Adding Noise image\n",
    "                    temp_img = noise_image(temp_img)\n",
    "                    \n",
    "                elif j == 'blur':\n",
    "                    # Adding Blur image\n",
    "                    temp_img = blur_image(temp_img)\n",
    "                    #imshow(blur_img)\n",
    "                    \n",
    "    \n",
    "                elif j == 'affine':\n",
    "                    open_cv_affine = np.array(pil_img)\n",
    "                    # Adding affine rotation image\n",
    "                    temp_img = affine_rotation(open_cv_affine)\n",
    "\n",
    "                elif j == 'gradient':\n",
    "                    open_cv_gradient = np.array(pil_img)\n",
    "                    # Adding gradient image\n",
    "                    temp_img = gradient_fill(open_cv_gradient)\n",
    "  \n",
    "            temp_img = img_to_array(temp_img)\n",
    "            data.append(temp_img)\n",
    "            labels.append(label)\n",
    "\n",
    "print(len(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success\n"
     ]
    }
   ],
   "source": [
    "data = np.asarray(data, dtype=\"int\") / 255.0\n",
    "labels = np.array(labels)\n",
    "print(\"Success\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, ..., 3, 3, 3])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 1.]\n",
      " [0. 0. 0. 0. 1.]\n",
      " ...\n",
      " [0. 0. 0. 0. 1.]\n",
      " [0. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 1.]]\n",
      "[[0. 0. 0. 0. 1.]\n",
      " [1. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 1.]\n",
      " ...\n",
      " [1. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 1.]\n",
      " [0. 0. 1. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# partition the data into training and testing splits using 75% of\n",
    "# the data for training and the remaining 25% for testing\n",
    "(trainX, testX, trainY, testY) =  train_test_split(data,labels, test_size=0.25, random_state=42)\n",
    "# convert the labels from integers to vectors\n",
    "try:\n",
    "    trainY = to_categorical(trainY, num_classes=5) ## input of to_categorial is class vector of integers\n",
    "    print(trainY)\n",
    "except Exception as ex:\n",
    "    trainY = None\n",
    "    print(ex)\n",
    "try:\n",
    "    testY = to_categorical(testY, num_classes=5)\n",
    "    print(testY)\n",
    "except Exception as ex:\n",
    "    testY = None\n",
    "    print(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "aug = ImageDataGenerator(rotation_range=30, width_shift_range=0.1,height_shift_range=0.1, shear_range=0.2, zoom_range=0.2,horizontal_flip=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'channels_last'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K.image_data_format()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LPQ Feature Calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# coding: utf-8\n",
    "import numpy as np\n",
    "from scipy.signal import convolve2d\n",
    "\n",
    "class LPQ(object):\n",
    "    \"\"\" This implementation of Local Phase Quantization (LPQ) is a \n",
    "      \n",
    "      Reference: \n",
    "        Ojansivu V & Heikkilä J (2008) Blur insensitive texture classification \n",
    "        using local phase quantization. Proc. Image and Signal Processing \n",
    "\t(ICISP 2008), Cherbourg-Octeville, France, 5099:236-243.\n",
    "        Copyright 2008 by Heikkilä & Ojansivu\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, radius=3):\n",
    "        self.radius = radius\n",
    "\n",
    "    def euc_dist(self, X):\n",
    "        Y = X = X.astype(np.int32)\n",
    "        XX = np.sum(X * X, axis=1)[:, np.newaxis]\n",
    "        YY = XX.T\n",
    "        distances = np.dot(X,Y.T)\n",
    "        distances *= -2\n",
    "        distances += XX\n",
    "        distances += YY\n",
    "        np.maximum(distances, 0, distances)\n",
    "        distances.flat[::distances.shape[0] + 1] = 0.0\n",
    "        return np.sqrt(distances)\n",
    "\n",
    "    def __call__(self,X):\n",
    "        f = 1.0\n",
    "        x = np.arange(-self.radius,self.radius+1)\n",
    "        n = len(x)\n",
    "        rho = 0.95\n",
    "        [xp, yp] = np.meshgrid(np.arange(1,(n+1)),np.arange(1,(n+1)))\n",
    "        pp = np.concatenate((xp,yp)).reshape(2,-1)\n",
    "        dd = self.euc_dist(pp.T) # squareform(pdist(...)) would do the job, too...\n",
    "        C = np.power(rho,dd)\n",
    "\n",
    "        w0 = (x*0.0+1.0)\n",
    "        w1 = np.exp(-2*np.pi*1j*x*f/n)\n",
    "        w2 = np.conj(w1)\n",
    "\n",
    "        q1 = w0.reshape(-1,1)*w1\n",
    "        q2 = w1.reshape(-1,1)*w0\n",
    "        q3 = w1.reshape(-1,1)*w1\n",
    "        q4 = w1.reshape(-1,1)*w2\n",
    "\n",
    "        u1 = np.real(q1)\n",
    "        u2 = np.imag(q1)\n",
    "        u3 = np.real(q2)\n",
    "        u4 = np.imag(q2)\n",
    "        u5 = np.real(q3)\n",
    "        u6 = np.imag(q3)\n",
    "        u7 = np.real(q4)\n",
    "        u8 = np.imag(q4)\n",
    "\n",
    "        M = np.matrix([u1.flatten(), u2.flatten(), u3.flatten(), u4.flatten(), u5.flatten(), u6.flatten(), u7.flatten(), u8.flatten()])\n",
    "\n",
    "        D = np.dot(np.dot(M,C), M.T)\n",
    "        U,S,V = np.linalg.svd(D)\n",
    "\n",
    "        Qa = convolve2d(convolve2d(X,w0.reshape(-1,1),mode='same'),w1.reshape(1,-1),mode='same')\n",
    "        Qb = convolve2d(convolve2d(X,w1.reshape(-1,1),mode='same'),w0.reshape(1,-1),mode='same')\n",
    "        Qc = convolve2d(convolve2d(X,w1.reshape(-1,1),mode='same'),w1.reshape(1,-1),mode='same')\n",
    "        Qd = convolve2d(convolve2d(X, w1.reshape(-1,1),mode='same'),w2.reshape(1,-1),mode='same')\n",
    "\n",
    "        Fa = np.real(Qa)\n",
    "        Ga = np.imag(Qa)\n",
    "        Fb = np.real(Qb) \n",
    "        Gb = np.imag(Qb)\n",
    "        Fc = np.real(Qc) \n",
    "        Gc = np.imag(Qc)\n",
    "        Fd = np.real(Qd) \n",
    "        Gd = np.imag(Qd)\n",
    "\n",
    "        F = np.array([Fa.flatten(), Ga.flatten(), Fb.flatten(), Gb.flatten(), Fc.flatten(), Gc.flatten(), Fd.flatten(), Gd.flatten()])\n",
    "        G = np.dot(V.T, F)\n",
    "\n",
    "        t = 0\n",
    "\n",
    "        # Calculate the LPQ Patterns:\n",
    "        B = (G[0,:]>=t)*1 + (G[1,:]>=t)*2 + (G[2,:]>=t)*4 + (G[3,:]>=t)*8 + (G[4,:]>=t)*16 + (G[5,:]>=t)*32 + (G[6,:]>=t)*64 + (G[7,:]>=t)*128\n",
    "        B = np.reshape(B, np.shape(Fa))\n",
    "\n",
    "        # And finally build the histogram:\n",
    "        h, b  = np.histogram(B, bins=256, range = (0,255))\n",
    "\n",
    "        return h\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"LPQ (radius=%s)\" % (self.radius)\n",
    "\n",
    "#len(trainX)\n",
    "#\n",
    "#trainX.shape\n",
    "\n",
    "lpq = LPQ(3)\n",
    "\n",
    "#lpq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculate Testing LPQ Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5592, 256)\n",
      "(1864, 256)\n",
      "5592\n",
      "1864\n"
     ]
    }
   ],
   "source": [
    "dim = (testX.shape[1],testX.shape[1])\n",
    "test_feat =[]\n",
    "for i in range(len(testX)):\n",
    "    X= testX[i]\n",
    "    X = X.reshape(dim)\n",
    "    lpq_feat = lpq(X)\n",
    "    test_feat.append(lpq_feat)\n",
    "\n",
    "train_feat =[]\n",
    "for i in range(len(trainX)):\n",
    "    X= trainX[i]\n",
    "    X = X.reshape(dim)\n",
    "    lpq_feat = lpq(X)\n",
    "    train_feat.append(lpq_feat)\n",
    "\n",
    "train_feat = np.array(train_feat)\n",
    "print(train_feat.shape)\n",
    "test_feat = np.array(test_feat)\n",
    "print(test_feat.shape)\n",
    "numTrain = int(pd.to_numeric(trainX.shape[0]))\n",
    "print(numTrain)\n",
    "numTest = int(pd.to_numeric(testX.shape[0]))\n",
    "print(numTest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "model.add(Conv1D(filters=32, kernel_size=12, input_shape=(256,1)))\n",
    "model.add(BatchNormalization())\n",
    "model.add(MaxPooling1D(pool_size=2))\n",
    "\n",
    "model.add(Conv1D(64, kernel_size=24, activation='relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(MaxPooling1D(pool_size=2))\n",
    "\n",
    "model.add(Conv1D(256, kernel_size=12, activation='relu'))\n",
    "model.add(Conv1D(256, kernel_size=12, activation='relu'))\n",
    "model.add(Conv1D(256, kernel_size=12, activation='relu'))\n",
    "\n",
    "model.add(Flatten())\n",
    "model.add(Dense(4096, activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(4096,activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(2383,activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dense(5, activation='softmax'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Compilation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reshaping LPQ training and testing features according to input of CNN here 256 is no of features per image\n",
    "train_feat = train_feat.reshape((len(train_feat),256,1))\n",
    "test_feat = test_feat.reshape((len(test_feat),256,1))\n",
    "batch_size = 16\n",
    "epochs = 2\n",
    "sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)\n",
    "model.compile(loss='mean_squared_error', optimizer=sgd, metrics=['accuracy'])\n",
    "\n",
    "early_stopping=callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1, mode='min')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv1d (Conv1D)             (None, 245, 32)           416       \n",
      "                                                                 \n",
      " batch_normalization (BatchN  (None, 245, 32)          128       \n",
      " ormalization)                                                   \n",
      "                                                                 \n",
      " max_pooling1d (MaxPooling1D  (None, 122, 32)          0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv1d_1 (Conv1D)           (None, 99, 64)            49216     \n",
      "                                                                 \n",
      " batch_normalization_1 (Batc  (None, 99, 64)           256       \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " max_pooling1d_1 (MaxPooling  (None, 49, 64)           0         \n",
      " 1D)                                                             \n",
      "                                                                 \n",
      " conv1d_2 (Conv1D)           (None, 38, 256)           196864    \n",
      "                                                                 \n",
      " conv1d_3 (Conv1D)           (None, 27, 256)           786688    \n",
      "                                                                 \n",
      " conv1d_4 (Conv1D)           (None, 16, 256)           786688    \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 4096)              0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 4096)              16781312  \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 4096)              0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 4096)              16781312  \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 4096)              0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 2383)              9763151   \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 2383)              0         \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 128)               305152    \n",
      "                                                                 \n",
      " dense_4 (Dense)             (None, 5)                 645       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 45,451,828\n",
      "Trainable params: 45,451,636\n",
      "Non-trainable params: 192\n",
      "_________________________________________________________________\n",
      "None\n",
      "Epoch 1/2\n",
      "\n",
      "Epoch 1: val_loss improved from inf to 0.01508, saving model to model.h5\n",
      "350/350 - 175s - loss: 0.0132 - accuracy: 0.9580 - val_loss: 0.0151 - val_accuracy: 0.9480 - 175s/epoch - 501ms/step\n",
      "Epoch 2/2\n",
      "\n",
      "Epoch 2: val_loss improved from 0.01508 to 0.00873, saving model to model.h5\n",
      "350/350 - 200s - loss: 0.0103 - accuracy: 0.9666 - val_loss: 0.0087 - val_accuracy: 0.9737 - 200s/epoch - 572ms/step\n"
     ]
    }
   ],
   "source": [
    "# file path where the model weights will be stored\n",
    "filepath=\"model.h5\"\n",
    "\n",
    "checkpoint = callbacks.ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min')\n",
    "\n",
    "callbacks_list = [early_stopping,checkpoint]\n",
    "\n",
    "print(model.summary())\n",
    "\n",
    "history = model.fit(train_feat, trainY,shuffle=True,\n",
    "          batch_size=batch_size,\n",
    "          epochs=epochs,\n",
    "          verbose=2,\n",
    "          validation_data=(test_feat, testY),callbacks=callbacks_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss and Accuracy Curve of Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# list all data in history\n",
    "print(history.history.keys())\n",
    "# summarize history for accuracy\n",
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 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": "markdown",
   "metadata": {},
   "source": [
    "## Load Save Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.004672890994697809\n",
      "Test accuracy: 0.9855149984359741\n"
     ]
    }
   ],
   "source": [
    "from keras.models import load_model\n",
    "model = load_model('model.h5')\n",
    "\n",
    "score = model.evaluate(test_feat, testY, verbose=0)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}