plant_disease_detection_trial.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "plant_disease_detection_trial.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyNNRL6MHivvzBBBu9L4bZAf"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9NlMoUYq5btU"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import os\n",
        "# os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n",
        "import time\n",
        "import matplotlib.pyplot as plt\n",
        "import cv2\n",
        "import seaborn as sns\n",
        "sns.set_style('darkgrid')\n",
        "import shutil\n",
        "from sklearn.metrics import confusion_matrix, classification_report\n",
        "from sklearn.model_selection import train_test_split\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from tensorflow.keras.layers import Dense, Activation,Dropout,Conv2D, MaxPooling2D,BatchNormalization\n",
        "from tensorflow.keras.optimizers import Adam, Adamax\n",
        "from tensorflow.keras.metrics import categorical_crossentropy\n",
        "from tensorflow.keras import regularizers\n",
        "from tensorflow.keras.models import Model\n",
        "import time"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import zipfile\n",
        "import shutil\n",
        "\n",
        "# path = '/Users/thecodinguru/Downloads/Image Database'\n",
        "# with zipfile.ZipFile(path,\"r\") as zip_ref:\n",
        "#     zip_ref.extractall(\"/content/image_database_raw\")\n",
        "\n",
        "\n",
        "# Path of the file\n",
        "filename = '/content/Image Data base.zip'\n",
        "\n",
        "# Target directory\n",
        "extract_dir = \"/content/image_database_raw\"\n",
        "\n",
        "# Unzip the file \n",
        "shutil.unpack_archive(filename, extract_dir)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 353
        },
        "id": "IRDcIoVb-ph6",
        "outputId": "d3de262b-a2ab-4d45-d7f7-96cb2a6dab5c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ReadError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mReadError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-14-4c20711009a1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;31m# Unzip the file\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mshutil\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munpack_archive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextract_dir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/lib/python3.7/shutil.py\u001b[0m in \u001b[0;36munpack_archive\u001b[0;34m(filename, extract_dir, format)\u001b[0m\n\u001b[1;32m   1000\u001b[0m         \u001b[0mfunc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_UNPACK_FORMATS\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1001\u001b[0m         \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_UNPACK_FORMATS\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1002\u001b[0;31m         \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextract_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1003\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1004\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/shutil.py\u001b[0m in \u001b[0;36m_unpack_zipfile\u001b[0;34m(filename, extract_dir)\u001b[0m\n\u001b[1;32m    897\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    898\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mzipfile\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_zipfile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 899\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mReadError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"%s is not a zip file\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    900\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    901\u001b[0m     \u001b[0mzip\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mzipfile\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mZipFile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mReadError\u001b[0m: /content/Image Data base.zip is not a zip file"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Read in images and create a dataframe of image paths and class labels"
      ],
      "metadata": {
        "id": "vFaj0gNG5kbF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sdir=r'/Users/thecodinguru/Downloads/Image Database'\n",
        "min_samples=40 # set limit for minimum images a class must have to be included in the dataframe\n",
        "filepaths = []\n",
        "labels=[] \n",
        "classlist=os.listdir(sdir)\n",
        "\n",
        "for klass in classlist:\n",
        "    classpath=os.path.join(sdir, klass)\n",
        "    flist=os.listdir(classpath)\n",
        "    if len(flist) >= min_samples:\n",
        "        for f in flist:\n",
        "            fpath=os.path.join(classpath,f)\n",
        "            filepaths.append(fpath)\n",
        "            labels.append(klass)\n",
        "    else:\n",
        "        print('class ', klass, ' has only', len(flist), ' samples and will not be included in dataframe')\n",
        "\n",
        "Fseries=pd.Series(filepaths, name='filepaths')\n",
        "Lseries=pd.Series(labels, name='labels')\n",
        "\n",
        "df=pd.concat([Fseries, Lseries], axis=1)\n",
        "\n",
        "train_df, dummy_df=train_test_split(df, train_size=.9, shuffle=True, random_state=123, stratify=df['labels'])\n",
        "valid_df, test_df=train_test_split(dummy_df, train_size=.5, shuffle=True, random_state=123, stratify=dummy_df['labels'])\n",
        "print('train_df lenght: ', len(train_df), '  test_df length: ', len(test_df), '  valid_df length: ', len(valid_df))\n",
        "\n",
        "# get the number of classes and the images count for each class in train_df\n",
        "classes=sorted(list(train_df['labels'].unique()))\n",
        "class_count = len(classes)\n",
        "print('The number of classes in the dataset is: ', class_count)\n",
        "groups=train_df.groupby('labels')\n",
        "print('{0:^30s} {1:^13s}'.format('CLASS', 'IMAGE COUNT'))\n",
        "countlist=[]\n",
        "classlist=[]\n",
        "for label in sorted(list(train_df['labels'].unique())):\n",
        "    group=groups.get_group(label)\n",
        "    countlist.append(len(group))\n",
        "    classlist.append(label)\n",
        "    print('{0:^30s} {1:^13s}'.format(label, str(len(group))))\n",
        "\n",
        "# get the classes with the minimum and maximum number of train images\n",
        "max_value=np.max(countlist)\n",
        "max_index=countlist.index(max_value)\n",
        "max_class=classlist[max_index]\n",
        "min_value=np.min(countlist)\n",
        "min_index=countlist.index(min_value)\n",
        "min_class=classlist[min_index]\n",
        "print(max_class, ' has the most images= ',max_value, ' ', min_class, ' has the least images= ', min_value)\n",
        "\n",
        "# lets get the average height and width of a sample of the train images\n",
        "ht=0\n",
        "wt=0\n",
        "\n",
        "# select 100 random samples of train_df\n",
        "train_df_sample=train_df.sample(n=100, random_state=123,axis=0)\n",
        "for i in range (len(train_df_sample)):\n",
        "    fpath=train_df_sample['filepaths'].iloc[i]\n",
        "    img=plt.imread(fpath)\n",
        "    shape=img.shape\n",
        "    ht += shape[0]\n",
        "    wt += shape[1]\n",
        "print('average height= ', ht//100, ' average width= ', wt//100, 'aspect ratio= ', ht/wt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 240
        },
        "id": "iaiJKuBc5mab",
        "outputId": "040d62c9-729d-4012-a47b-8b90b4da205d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-13-36b2c733ce19>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mfilepaths\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mclasslist\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mklass\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mclasslist\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/thecodinguru/Downloads/Image Database'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Trim train_df so no class has more than 200 images"
      ],
      "metadata": {
        "id": "5amMaGQJ6Tux"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def trim(df, max_samples, min_samples, column):\n",
        "    df=df.copy()\n",
        "    groups=df.groupby(column)    \n",
        "    trimmed_df = pd.DataFrame(columns = df.columns)\n",
        "    groups=df.groupby(column)\n",
        "    for label in df[column].unique(): \n",
        "        group=groups.get_group(label)\n",
        "        count=len(group)    \n",
        "        if count > max_samples:\n",
        "            sampled_group=group.sample(n=max_samples, random_state=123,axis=0)\n",
        "            trimmed_df=pd.concat([trimmed_df, sampled_group], axis=0)\n",
        "        else:\n",
        "            if count>=min_samples:\n",
        "                sampled_group=group        \n",
        "                trimmed_df=pd.concat([trimmed_df, sampled_group], axis=0)\n",
        "    print('after trimming, the maximum samples in any class is now ',max_samples, ' and the minimum samples in any class is ', min_samples)\n",
        "    return trimmed_df\n",
        "\n",
        "max_samples=200 # since each class has more than 200 images all classes will be trimmed to have 200 images per class\n",
        "min_samples=36\n",
        "column='labels'\n",
        "train_df= trim(train_df, max_samples, min_samples, column)"
      ],
      "metadata": {
        "id": "1R0havHh5yq2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Balance train_df by creating augmented images"
      ],
      "metadata": {
        "id": "sVKvVEGk6ZHK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def balance(df, n, working_dir, img_size):\n",
        "    df=df.copy()\n",
        "    print('Initial length of dataframe is ', len(df))\n",
        "    aug_dir=os.path.join(working_dir, 'aug')# directory to store augmented images\n",
        "    if os.path.isdir(aug_dir):# start with an empty directory\n",
        "        shutil.rmtree(aug_dir)\n",
        "    os.mkdir(aug_dir)        \n",
        "    for label in df['labels'].unique():    \n",
        "        dir_path=os.path.join(aug_dir,label)    \n",
        "        os.mkdir(dir_path) # make class directories within aug directory\n",
        "    # create and store the augmented images  \n",
        "    total=0\n",
        "    gen=ImageDataGenerator(horizontal_flip=True,  rotation_range=20, width_shift_range=.2,\n",
        "                                  height_shift_range=.2, zoom_range=.2)\n",
        "    groups=df.groupby('labels') # group by class\n",
        "    for label in df['labels'].unique():  # for every class               \n",
        "        group=groups.get_group(label)  # a dataframe holding only rows with the specified label \n",
        "        sample_count=len(group)   # determine how many samples there are in this class        \n",
        "        if sample_count< n: # if the class has less than target number of images\n",
        "            aug_img_count=0\n",
        "            delta=n - sample_count  # number of augmented images to create\n",
        "            target_dir=os.path.join(aug_dir, label)  # define where to write the images\n",
        "            msg='{0:40s} for class {1:^30s} creating {2:^5s} augmented images'.format(' ', label, str(delta))\n",
        "            print(msg, '\\r', end='') # prints over on the same line\n",
        "            aug_gen=gen.flow_from_dataframe( group,  x_col='filepaths', y_col=None, target_size=img_size,\n",
        "                                            class_mode=None, batch_size=1, shuffle=False, \n",
        "                                            save_to_dir=target_dir, save_prefix='aug-', color_mode='rgb',\n",
        "                                            save_format='jpg')\n",
        "            while aug_img_count<delta:\n",
        "                images=next(aug_gen)            \n",
        "                aug_img_count += len(images)\n",
        "            total +=aug_img_count\n",
        "    print('Total Augmented images created= ', total)\n",
        "    # create aug_df and merge with train_df to create composite training set ndf\n",
        "    aug_fpaths=[]\n",
        "    aug_labels=[]\n",
        "    classlist=os.listdir(aug_dir)\n",
        "    for klass in classlist:\n",
        "        classpath=os.path.join(aug_dir, klass)     \n",
        "        flist=os.listdir(classpath)    \n",
        "        for f in flist:        \n",
        "            fpath=os.path.join(classpath,f)         \n",
        "            aug_fpaths.append(fpath)\n",
        "            aug_labels.append(klass)\n",
        "    Fseries=pd.Series(aug_fpaths, name='filepaths')\n",
        "    Lseries=pd.Series(aug_labels, name='labels')\n",
        "    aug_df=pd.concat([Fseries, Lseries], axis=1)         \n",
        "    df=pd.concat([df,aug_df], axis=0).reset_index(drop=True)\n",
        "    print('Length of augmented dataframe is now ', len(df))\n",
        "    return df \n",
        "\n",
        "n=200 # number of samples in each class\n",
        "working_dir=r'./' # directory to store augmented images\n",
        "img_size=(200,200) # size of augmented images\n",
        "train_df=balance(train_df, n, working_dir, img_size) "
      ],
      "metadata": {
        "id": "SV9NxGNT6cHl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create the train_gen, test_gen final_test_gen and valid_gen"
      ],
      "metadata": {
        "id": "iciCjQIv6gRb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "batch_size=20 # We will use and EfficientetB3 model, with image size of (200, 250) this size should not cause resource error\n",
        "trgen=ImageDataGenerator(horizontal_flip=True,rotation_range=20, width_shift_range=.2,\n",
        "                                  height_shift_range=.2, zoom_range=.2 )\n",
        "t_and_v_gen=ImageDataGenerator()\n",
        "msg='{0:70s} for train generator'.format(' ')\n",
        "print(msg, '\\r', end='') # prints over on the same line\n",
        "train_gen=trgen.flow_from_dataframe(train_df, x_col='filepaths', y_col='labels', target_size=img_size,\n",
        "                                   class_mode='categorical', color_mode='rgb', shuffle=True, batch_size=batch_size)\n",
        "msg='{0:70s} for valid generator'.format(' ')\n",
        "print(msg, '\\r', end='') # prints over on the same line\n",
        "valid_gen=t_and_v_gen.flow_from_dataframe(valid_df, x_col='filepaths', y_col='labels', target_size=img_size,\n",
        "                                   class_mode='categorical', color_mode='rgb', shuffle=False, batch_size=batch_size)\n",
        "# for the test_gen we want to calculate the batch size and test steps such that batch_size X test_steps= number of samples in test set\n",
        "# this insures that we go through all the sample in the test set exactly once.\n",
        "length=len(test_df)\n",
        "test_batch_size=sorted([int(length/n) for n in range(1,length+1) if length % n ==0 and length/n<=80],reverse=True)[0]  \n",
        "test_steps=int(length/test_batch_size)\n",
        "msg='{0:70s} for test generator'.format(' ')\n",
        "print(msg, '\\r', end='') # prints over on the same line\n",
        "test_gen=t_and_v_gen.flow_from_dataframe(test_df, x_col='filepaths', y_col='labels', target_size=img_size,\n",
        "                                   class_mode='categorical', color_mode='rgb', shuffle=False, batch_size=test_batch_size)\n",
        "# from the generator we can get information we will need later\n",
        "classes=list(train_gen.class_indices.keys())\n",
        "class_indices=list(train_gen.class_indices.values())\n",
        "class_count=len(classes)\n",
        "labels=test_gen.labels\n",
        "print ( 'test batch size: ' ,test_batch_size, '  test steps: ', test_steps, ' number of classes : ', class_count)"
      ],
      "metadata": {
        "id": "JDcomsbI6mL2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a function to show example training images"
      ],
      "metadata": {
        "id": "lS05PVPu6s9d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def show_image_samples(gen ):\n",
        "    t_dict=gen.class_indices\n",
        "    classes=list(t_dict.keys())    \n",
        "    images,labels=next(gen) # get a sample batch from the generator \n",
        "    plt.figure(figsize=(20, 20))\n",
        "    length=len(labels)\n",
        "    if length<25:   #show maximum of 25 images\n",
        "        r=length\n",
        "    else:\n",
        "        r=25\n",
        "    for i in range(r):        \n",
        "        plt.subplot(5, 5, i + 1)\n",
        "        image=images[i] /255       \n",
        "        plt.imshow(image)\n",
        "        index=np.argmax(labels[i])\n",
        "        class_name=classes[index]\n",
        "        plt.title(class_name, color='blue', fontsize=14)\n",
        "        plt.axis('off')\n",
        "    plt.show()\n",
        "    \n",
        "show_image_samples(train_gen )"
      ],
      "metadata": {
        "id": "NdBxPJ_r6q7v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a model using transfer learning with EfficientNetB3"
      ],
      "metadata": {
        "id": "Sy4RunoM60i5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "img_shape=(img_size[0], img_size[1], 3)\n",
        "model_name='EfficientNetB3'\n",
        "base_model=tf.keras.applications.efficientnet.EfficientNetB3(include_top=False, weights=\"imagenet\",input_shape=img_shape, pooling='max') \n",
        "# Note you are always told NOT to make the base model trainable initially- that is WRONG you get better results leaving it trainable\n",
        "base_model.trainable=True\n",
        "x=base_model.output\n",
        "x=BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001 )(x)\n",
        "x = Dense(256, kernel_regularizer = regularizers.l2(l = 0.016),activity_regularizer=regularizers.l1(0.006),\n",
        "                bias_regularizer=regularizers.l1(0.006) ,activation='relu')(x)\n",
        "x=Dropout(rate=.4, seed=123)(x)       \n",
        "output=Dense(class_count, activation='softmax')(x)\n",
        "model=Model(inputs=base_model.input, outputs=output)\n",
        "lr=.001 # start with this learning rate\n",
        "model.compile(Adamax(learning_rate=lr), loss='categorical_crossentropy', metrics=['accuracy']) "
      ],
      "metadata": {
        "id": "8PVONtAp607s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Create a custom Keras callback to continue and optionally set LR or halt training**\n",
        "\n",
        "The LR_ASK callback is a convenient callback that allow to continue training for ask_epoch more epochs or to halt training.\n",
        "\n",
        "If you elect to continue training for more epochs you are given the option to retain the current learning rate (LR) or to\n",
        "enter a new value for the learning rate. The form of use is:\n",
        "ask=LR_ASK(model,epochs, ask_epoch) where:\n",
        "\n",
        "model is a string which is the name of your compiled model\n",
        "epochs is an integer which is the number of epochs to run specified in model.fit\n",
        "ask_epoch is an integer. If ask_epoch is set to a value say 5 then the model will train for 5 epochs.\n",
        "\n",
        "Then the user is ask to enter H to halt training, or enter an inter value. For example if you enter 4\n",
        "training will continue for 4 more epochs to epoch 9 then you will be queried again. Once you enter an\n",
        "integer value you are prompted to press ENTER to continue training using the current learning rate\n",
        "or to enter a new value for the learning rate.\n",
        "\n",
        "At the end of training the model weights are set to the weights for the epoch that achieved the lowest validation loss"
      ],
      "metadata": {
        "id": "YFnwj_ed6_2b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class LR_ASK(keras.callbacks.Callback):\n",
        "    def __init__ (self, model, epochs,  ask_epoch): # initialization of the callback\n",
        "        super(LR_ASK, self).__init__()\n",
        "        self.model=model               \n",
        "        self.ask_epoch=ask_epoch\n",
        "        self.epochs=epochs\n",
        "        self.ask=True # if True query the user on a specified epoch\n",
        "        self.lowest_vloss=np.inf\n",
        "        self.best_weights=self.model.get_weights() # set best weights to model's initial weights\n",
        "        self.best_epoch=1\n",
        "        \n",
        "        \n",
        "    def on_train_begin(self, logs=None): # this runs on the beginning of training\n",
        "        if self.ask_epoch == 0: \n",
        "            print('you set ask_epoch = 0, ask_epoch will be set to 1', flush=True)\n",
        "            self.ask_epoch=1\n",
        "        if self.ask_epoch >= self.epochs: # you are running for epochs but ask_epoch>epochs\n",
        "            print('ask_epoch >= epochs, will train for ', epochs, ' epochs', flush=True)\n",
        "            self.ask=False # do not query the user\n",
        "        if self.epochs == 1:\n",
        "            self.ask=False # running only for 1 epoch so do not query user\n",
        "        else:\n",
        "            print('Training will proceed until epoch', ask_epoch,' then you will be asked to') \n",
        "            print(' enter H to halt training or enter an integer for how many more epochs to run then be asked again')  \n",
        "        self.start_time= time.time() # set the time at which training started\n",
        "        \n",
        "    def on_train_end(self, logs=None):   # runs at the end of training  \n",
        "        print('loading model with weights from epoch ', self.best_epoch)\n",
        "        self.model.set_weights(self.best_weights) # set the weights of the model to the best weights\n",
        "        tr_duration=time.time() - self.start_time   # determine how long the training cycle lasted         \n",
        "        hours = tr_duration // 3600\n",
        "        minutes = (tr_duration - (hours * 3600)) // 60\n",
        "        seconds = tr_duration - ((hours * 3600) + (minutes * 60))\n",
        "        msg = f'training elapsed time was {str(hours)} hours, {minutes:4.1f} minutes, {seconds:4.2f} seconds)'\n",
        "        print (msg, flush=True) # print out training duration time\n",
        "        \n",
        "    def on_epoch_end(self, epoch, logs=None):  # method runs on the end of each epoch\n",
        "        v_loss=logs.get('val_loss')  # get the validation loss for this epoch\n",
        "        if v_loss< self.lowest_vloss:\n",
        "            self.lowest_vloss=v_loss\n",
        "            self.best_weights=self.model.get_weights() # set best weights to model's initial weights\n",
        "            self.best_epoch=epoch + 1\n",
        "            print (f'\\n validation loss of {v_loss:7.4f} is below lowest loss, saving weights from epoch {str(epoch + 1):3s} as best weights')\n",
        "        else:\n",
        "            print (f'\\n validation loss of {v_loss:7.4f} is above lowest loss of {self.lowest_vloss:7.4f} keeping weights from epoch {str(self.best_epoch)} as best weights')\n",
        "        \n",
        "        if self.ask: # are the conditions right to query the user?\n",
        "            if epoch + 1 ==self.ask_epoch: # is this epoch the one for quering the user?\n",
        "                print('\\n Enter H to end training or  an integer for the number of additional epochs to run then ask again')\n",
        "                ans=input()\n",
        "                \n",
        "                if ans == 'H' or ans =='h' or ans == '0': # quit training for these conditions\n",
        "                    print ('you entered ', ans, ' Training halted on epoch ', epoch+1, ' due to user input\\n', flush=True)\n",
        "                    self.model.stop_training = True # halt training\n",
        "                else: # user wants to continue training\n",
        "                    self.ask_epoch += int(ans)\n",
        "                    if self.ask_epoch > self.epochs:\n",
        "                        print('\\nYou specified maximum epochs of as ', self.epochs, ' cannot train for ', self.ask_epoch, flush =True)\n",
        "                    else:\n",
        "                        print ('you entered ', ans, ' Training will continue to epoch ', self.ask_epoch, flush=True)\n",
        "                        lr=float(tf.keras.backend.get_value(self.model.optimizer.lr)) # get the current learning rate\n",
        "                        print(f'current LR is  {lr:7.5f}  hit enter to keep  this LR or enter a new LR')\n",
        "                        ans=input(' ')\n",
        "                        if ans =='':\n",
        "                            print (f'keeping current LR of {lr:7.5f}')\n",
        "                        else:\n",
        "                            new_lr=float(ans)\n",
        "                            tf.keras.backend.set_value(self.model.optimizer.lr, new_lr) # set the learning rate in the optimizer\n",
        "                            print(' changing LR to ', ans)"
      ],
      "metadata": {
        "id": "z44hQsHi7yYh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Instantiate custom callback"
      ],
      "metadata": {
        "id": "xEN9dyfJ73rz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "epochs=40\n",
        "ask_epoch=5\n",
        "ask=LR_ASK(model, epochs,  ask_epoch)\n",
        "#rlronp=tf.keras.callbacks.ReduceLROnPlateau(monitor=\"val_loss\", factor=0.5, patience=2,verbose=1)\n",
        "#callbacks=[rlronp, ask]\n",
        "callbacks=[ask]"
      ],
      "metadata": {
        "id": "BXgZ8jG_730a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Train the model"
      ],
      "metadata": {
        "id": "nP7GVZwq74EV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "history=model.fit(x=train_gen,  epochs=epochs, verbose=1, callbacks=callbacks,  validation_data=valid_gen,\n",
        "               validation_steps=None,  shuffle=False,  initial_epoch=0)"
      ],
      "metadata": {
        "id": "IUAX8gLN74NM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define a function to plot the training data"
      ],
      "metadata": {
        "id": "UH6tfVtX74b0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def tr_plot(tr_data, start_epoch):\n",
        "    #Plot the training and validation data\n",
        "    tacc=tr_data.history['accuracy']\n",
        "    tloss=tr_data.history['loss']\n",
        "    vacc=tr_data.history['val_accuracy']\n",
        "    vloss=tr_data.history['val_loss']\n",
        "    Epoch_count=len(tacc)+ start_epoch\n",
        "    Epochs=[]\n",
        "    for i in range (start_epoch ,Epoch_count):\n",
        "        Epochs.append(i+1)   \n",
        "    index_loss=np.argmin(vloss)#  this is the epoch with the lowest validation loss\n",
        "    val_lowest=vloss[index_loss]\n",
        "    index_acc=np.argmax(vacc)\n",
        "    acc_highest=vacc[index_acc]\n",
        "    plt.style.use('fivethirtyeight')\n",
        "    sc_label='best epoch= '+ str(index_loss+1 +start_epoch)\n",
        "    vc_label='best epoch= '+ str(index_acc + 1+ start_epoch)\n",
        "    fig,axes=plt.subplots(nrows=1, ncols=2, figsize=(20,8))\n",
        "    axes[0].plot(Epochs,tloss, 'r', label='Training loss')\n",
        "    axes[0].plot(Epochs,vloss,'g',label='Validation loss' )\n",
        "    axes[0].scatter(index_loss+1 +start_epoch,val_lowest, s=150, c= 'blue', label=sc_label)\n",
        "    axes[0].set_title('Training and Validation Loss')\n",
        "    axes[0].set_xlabel('Epochs')\n",
        "    axes[0].set_ylabel('Loss')\n",
        "    axes[0].legend()\n",
        "    axes[1].plot (Epochs,tacc,'r',label= 'Training Accuracy')\n",
        "    axes[1].plot (Epochs,vacc,'g',label= 'Validation Accuracy')\n",
        "    axes[1].scatter(index_acc+1 +start_epoch,acc_highest, s=150, c= 'blue', label=vc_label)\n",
        "    axes[1].set_title('Training and Validation Accuracy')\n",
        "    axes[1].set_xlabel('Epochs')\n",
        "    axes[1].set_ylabel('Accuracy')\n",
        "    axes[1].legend()\n",
        "    plt.tight_layout    \n",
        "    plt.show()\n",
        "    \n",
        "tr_plot(history,0)"
      ],
      "metadata": {
        "id": "qpw1M4qM74ku"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Make Predictions on the test set**\n",
        "\n",
        "Define a function which takes in a test generator and an integer test_steps\n",
        "and generates predictions on the test set including a confusion matric\n",
        "and a classification report"
      ],
      "metadata": {
        "id": "kW2C7ctc8LXR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def predictor(test_gen, test_steps):\n",
        "    y_pred= []\n",
        "    y_true=test_gen.labels\n",
        "    classes=list(test_gen.class_indices.keys())\n",
        "    class_count=len(classes)\n",
        "    errors=0\n",
        "    preds=model.predict(test_gen, verbose=1)\n",
        "    tests=len(preds)    \n",
        "    for i, p in enumerate(preds):        \n",
        "        pred_index=np.argmax(p)         \n",
        "        true_index=test_gen.labels[i]  # labels are integer values        \n",
        "        if pred_index != true_index: # a misclassification has occurred                                           \n",
        "            errors=errors + 1\n",
        "        y_pred.append(pred_index)\n",
        "            \n",
        "    acc=( 1-errors/tests) * 100 \n",
        "    print(f'there were {errors} errors in {tests} tests for an accuracy of {acc:6.2f}')\n",
        "    ypred=np.array(y_pred)\n",
        "    ytrue=np.array(y_true)\n",
        "    if class_count <=30:\n",
        "        cm = confusion_matrix(ytrue, ypred )\n",
        "        # plot the confusion matrix\n",
        "        plt.figure(figsize=(12, 8))\n",
        "        sns.heatmap(cm, annot=True, vmin=0, fmt='g', cmap='Blues', cbar=False)       \n",
        "        plt.xticks(np.arange(class_count)+.5, classes, rotation=90)\n",
        "        plt.yticks(np.arange(class_count)+.5, classes, rotation=0)\n",
        "        plt.xlabel(\"Predicted\")\n",
        "        plt.ylabel(\"Actual\")\n",
        "        plt.title(\"Confusion Matrix\")\n",
        "        plt.show()\n",
        "    clr = classification_report(y_true, y_pred, target_names=classes, digits= 4) # create classification report\n",
        "    print(\"Classification Report:\\n----------------------\\n\", clr)\n",
        "    return errors, tests\n",
        "errors, tests=predictor(test_gen, test_steps)"
      ],
      "metadata": {
        "id": "k1WKbYrt8Lm7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Save the model"
      ],
      "metadata": {
        "id": "0NKVLtLM8Lt6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "subject='plant disease' \n",
        "acc=str(( 1-errors/tests) * 100)\n",
        "index=acc.rfind('.')\n",
        "acc=acc[:index + 3]\n",
        "save_id= subject + '_' + str(acc) + '.h5' \n",
        "model_save_loc=os.path.join(working_dir, save_id)\n",
        "model.save(model_save_loc)\n",
        "print ('model was saved as ' , model_save_loc ) "
      ],
      "metadata": {
        "id": "vATmul5x8L24"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}