chlorophyll_model.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zDTOmB29ahit"
      },
      "source": [
        "# Model for leaf disease detection, using CNN."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QUQ-iHdLabnm",
        "outputId": "de665ea3-450d-40c7-d2e6-7a3305bf0466"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "# import drive to load the dataset (plant_village dataset)\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "LVOIyENwbkJD"
      },
      "outputs": [],
      "source": [
        "# # cp to colab (it might increase IO speed), and extract\n",
        "# !cp \"/content/drive/MyDrive/archive.zip\" \"/content\"\n",
        "# !unzip -q archive.zip\n",
        "\n",
        "# DATA_DIR = \"/content/archive/PlantVillage\""
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# cp to colab (it might increase IO speed), and extract\n",
        "!cp \"/content/drive/MyDrive/Plant_leaf_diseases_dataset_with_augmentation.zip\" \"/content\"\n",
        "!unzip -q Plant_leaf_diseases_dataset_with_augmentation.zip\n",
        "\n",
        "DATA_DIR = \"/content/Plant_leave_diseases_dataset_with_augmentation\""
      ],
      "metadata": {
        "id": "sVdCMdlTZeWZ"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zln776wpbgEc",
        "outputId": "d75bcb2c-c9f6-4645-b6d4-aa927c3200f7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 49197 images belonging to 39 classes.\n",
            "Found 12289 images belonging to 39 classes.\n",
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 126, 126, 16)      448       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 63, 63, 16)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 61, 61, 32)        4640      \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 30, 30, 32)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 28, 28, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 14, 14, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 12, 12, 64)        36928     \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 6, 6, 64)         0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_4 (Conv2D)           (None, 4, 4, 64)          36928     \n",
            "                                                                 \n",
            " max_pooling2d_4 (MaxPooling  (None, 2, 2, 64)         0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 256)               0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 512)               131584    \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 512)               0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 39)                20007     \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 249,031\n",
            "Trainable params: 249,031\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "import tensorflow as tf\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "IMAGE_SIZE = 128 # reduce input img size for faster training\n",
        "BATCH_SIZE = 64\n",
        "DROP = 0.9 # calculated through experimentation\n",
        "\n",
        "# we rescale all our images with the rescale parameter\n",
        "datagen = ImageDataGenerator(rescale=1.0 / 255, validation_split=0.2)\n",
        "# validation_datagen = ImageDataGenerator(rescale=1.0 / 255)\n",
        "\n",
        "train_generator = datagen.flow_from_directory(\n",
        "    DATA_DIR,\n",
        "    target_size=(IMAGE_SIZE, IMAGE_SIZE),\n",
        "    batch_size = BATCH_SIZE, #images getting inputed into the neural network through each epoch or each step\n",
        "    subset='training',\n",
        "    class_mode=\"categorical\"\n",
        ")\n",
        "\n",
        "num_classes = len(train_generator.class_indices)\n",
        "\n",
        "validation_generator = datagen.flow_from_directory(\n",
        "    DATA_DIR, \n",
        "    target_size=(IMAGE_SIZE, IMAGE_SIZE),\n",
        "    batch_size=BATCH_SIZE,\n",
        "    subset='validation',\n",
        "    class_mode=\"categorical\"\n",
        ")\n",
        "\n",
        "model = tf.keras.models.Sequential([\n",
        "    tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)),\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "\n",
        "    tf.keras.layers.Conv2D(32, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "\n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "\n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    \n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    \n",
        "    tf.keras.layers.Flatten(),\n",
        "    tf.keras.layers.Dense(512, activation='relu'),\n",
        "    tf.keras.layers.Dropout(DROP),\n",
        "    tf.keras.layers.Dense(num_classes, activation='softmax')\n",
        "])\n",
        "\n",
        "model.compile(optimizer=\"adam\", loss=\"categorical_crossentropy\", metrics=[\"accuracy\"])\n",
        "\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# train the model\n",
        "history = model.fit(\n",
        "    train_generator,\n",
        "    # steps_per_epoch=100,\n",
        "    epochs=20,\n",
        "    validation_data=validation_generator,\n",
        "    # validation_steps=50,\n",
        "    # verbose=2,\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uYRtBICkMOkZ",
        "outputId": "e7bb1516-a1fa-4c99-8625-04067ff5b1ba"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "769/769 [==============================] - 118s 141ms/step - loss: 2.8966 - accuracy: 0.2385 - val_loss: 2.0959 - val_accuracy: 0.4161\n",
            "Epoch 2/20\n",
            "769/769 [==============================] - 110s 142ms/step - loss: 1.9351 - accuracy: 0.4515 - val_loss: 1.2538 - val_accuracy: 0.6378\n",
            "Epoch 3/20\n",
            "769/769 [==============================] - 104s 135ms/step - loss: 1.4034 - accuracy: 0.5862 - val_loss: 0.9102 - val_accuracy: 0.7315\n",
            "Epoch 4/20\n",
            "769/769 [==============================] - 104s 136ms/step - loss: 1.1292 - accuracy: 0.6590 - val_loss: 0.7044 - val_accuracy: 0.7850\n",
            "Epoch 5/20\n",
            "769/769 [==============================] - 105s 137ms/step - loss: 0.9494 - accuracy: 0.7081 - val_loss: 0.6250 - val_accuracy: 0.8080\n",
            "Epoch 6/20\n",
            "769/769 [==============================] - 105s 137ms/step - loss: 0.8384 - accuracy: 0.7411 - val_loss: 0.4919 - val_accuracy: 0.8491\n",
            "Epoch 7/20\n",
            "769/769 [==============================] - 97s 126ms/step - loss: 0.7405 - accuracy: 0.7687 - val_loss: 0.4522 - val_accuracy: 0.8597\n",
            "Epoch 8/20\n",
            "769/769 [==============================] - 99s 129ms/step - loss: 0.6625 - accuracy: 0.7937 - val_loss: 0.4300 - val_accuracy: 0.8652\n",
            "Epoch 9/20\n",
            "769/769 [==============================] - 100s 130ms/step - loss: 0.5937 - accuracy: 0.8162 - val_loss: 0.4298 - val_accuracy: 0.8699\n",
            "Epoch 10/20\n",
            "769/769 [==============================] - 96s 125ms/step - loss: 0.5519 - accuracy: 0.8293 - val_loss: 0.3975 - val_accuracy: 0.8751\n",
            "Epoch 11/20\n",
            "769/769 [==============================] - 99s 128ms/step - loss: 0.5151 - accuracy: 0.8399 - val_loss: 0.3305 - val_accuracy: 0.9002\n",
            "Epoch 12/20\n",
            "769/769 [==============================] - 98s 127ms/step - loss: 0.4730 - accuracy: 0.8528 - val_loss: 0.3879 - val_accuracy: 0.8829\n",
            "Epoch 13/20\n",
            "769/769 [==============================] - 94s 122ms/step - loss: 0.4352 - accuracy: 0.8633 - val_loss: 0.3866 - val_accuracy: 0.8849\n",
            "Epoch 14/20\n",
            "769/769 [==============================] - 98s 127ms/step - loss: 0.4066 - accuracy: 0.8728 - val_loss: 0.3028 - val_accuracy: 0.9065\n",
            "Epoch 15/20\n",
            "769/769 [==============================] - 98s 128ms/step - loss: 0.3904 - accuracy: 0.8786 - val_loss: 0.3012 - val_accuracy: 0.9102\n",
            "Epoch 16/20\n",
            "769/769 [==============================] - 95s 123ms/step - loss: 0.3726 - accuracy: 0.8869 - val_loss: 0.2877 - val_accuracy: 0.9136\n",
            "Epoch 17/20\n",
            "769/769 [==============================] - 97s 127ms/step - loss: 0.3454 - accuracy: 0.8919 - val_loss: 0.2679 - val_accuracy: 0.9182\n",
            "Epoch 18/20\n",
            "769/769 [==============================] - 96s 125ms/step - loss: 0.3302 - accuracy: 0.8973 - val_loss: 0.2661 - val_accuracy: 0.9251\n",
            "Epoch 19/20\n",
            "769/769 [==============================] - 93s 121ms/step - loss: 0.3164 - accuracy: 0.9017 - val_loss: 0.2568 - val_accuracy: 0.9257\n",
            "Epoch 20/20\n",
            "769/769 [==============================] - 96s 125ms/step - loss: 0.3084 - accuracy: 0.9052 - val_loss: 0.2550 - val_accuracy: 0.9301\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# test the model\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "from google.colab import files\n",
        "from keras.utils import load_img, img_to_array\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "for fn in uploaded.keys():\n",
        " \n",
        "  # prediction on the uploaded image\n",
        "  path = '/content/' + fn\n",
        "  img = load_img(path, target_size=(IMAGE_SIZE, IMAGE_SIZE)) \n",
        "  \n",
        "  # scaling process\n",
        "  x = img_to_array(img)\n",
        "  x /= 255 \n",
        "  x = np.expand_dims(x, axis=0)\n",
        "  # flatten the output\n",
        "  image = np.vstack([x])\n",
        "  \n",
        "  # prediction!\n",
        "  classes = model.predict(image)\n",
        "  \n",
        "  print(classes[0], train_generator.class_indices)\n",
        "\n",
        "  print(list(classes[0]).index(max(classes[0])))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 302
        },
        "id": "9FLoCiVq4AC6",
        "outputId": "8872ad58-6d08-4e32-d142-9aa7ebb899aa"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-02c943ad-7f1c-4f07-a1fc-b95e7533ede0\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-02c943ad-7f1c-4f07-a1fc-b95e7533ede0\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving 1bff3ab2-9e99-4d4b-ad0e-acd943324050___RS_Erly.B 6460.JPG to 1bff3ab2-9e99-4d4b-ad0e-acd943324050___RS_Erly.B 6460 (2).JPG\n",
            "1/1 [==============================] - 0s 15ms/step\n",
            "[2.22684680e-08 1.32825513e-13 1.07343837e-07 1.09847358e-08\n",
            " 1.91480012e-10 3.45586054e-13 1.72206815e-11 2.84144554e-20\n",
            " 4.55185820e-11 7.77382529e-15 5.37724830e-11 3.50902294e-21\n",
            " 7.03347647e-09 8.82543347e-14 1.64575737e-13 7.03904761e-16\n",
            " 1.15414562e-11 3.09887764e-05 2.48358235e-12 8.22808147e-07\n",
            " 2.03123710e-15 1.94129652e-13 1.26252564e-08 1.11256004e-21\n",
            " 2.90179384e-18 4.69757019e-14 6.48020249e-11 6.17616791e-11\n",
            " 5.45009959e-21 1.80780023e-01 8.13782454e-01 4.89666534e-04\n",
            " 3.78006115e-03 1.11029227e-03 1.17626065e-07 2.52424093e-06\n",
            " 2.28566223e-05 3.00455182e-11 4.59502922e-11] {'Apple___Apple_scab': 0, 'Apple___Black_rot': 1, 'Apple___Cedar_apple_rust': 2, 'Apple___healthy': 3, 'Background_without_leaves': 4, 'Blueberry___healthy': 5, 'Cherry___Powdery_mildew': 6, 'Cherry___healthy': 7, 'Corn___Cercospora_leaf_spot Gray_leaf_spot': 8, 'Corn___Common_rust': 9, 'Corn___Northern_Leaf_Blight': 10, 'Corn___healthy': 11, 'Grape___Black_rot': 12, 'Grape___Esca_(Black_Measles)': 13, 'Grape___Leaf_blight_(Isariopsis_Leaf_Spot)': 14, 'Grape___healthy': 15, 'Orange___Haunglongbing_(Citrus_greening)': 16, 'Peach___Bacterial_spot': 17, 'Peach___healthy': 18, 'Pepper,_bell___Bacterial_spot': 19, 'Pepper,_bell___healthy': 20, 'Potato___Early_blight': 21, 'Potato___Late_blight': 22, 'Potato___healthy': 23, 'Raspberry___healthy': 24, 'Soybean___healthy': 25, 'Squash___Powdery_mildew': 26, 'Strawberry___Leaf_scorch': 27, 'Strawberry___healthy': 28, 'Tomato___Bacterial_spot': 29, 'Tomato___Early_blight': 30, 'Tomato___Late_blight': 31, 'Tomato___Leaf_Mold': 32, 'Tomato___Septoria_leaf_spot': 33, 'Tomato___Spider_mites Two-spotted_spider_mite': 34, 'Tomato___Target_Spot': 35, 'Tomato___Tomato_Yellow_Leaf_Curl_Virus': 36, 'Tomato___Tomato_mosaic_virus': 37, 'Tomato___healthy': 38}\n",
            "30\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "Gm0NI-nacgWG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 562
        },
        "outputId": "63227e8b-c69a-4d4f-9f8a-acdfed3d2f7b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Loss in training and validation')"
            ]
          },
          "metadata": {},
          "execution_count": 11
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# get the metrics from history\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs = range(len(acc)) \n",
        "\n",
        "# plot accuracy with matplotlib\n",
        "plt.plot(epochs, acc)\n",
        "plt.plot(epochs, val_acc)\n",
        "plt.title('Accuracy in training and validation')\n",
        "plt.figure()\n",
        "\n",
        "# plot loss with matplotlib\n",
        "plt.plot(epochs, loss)\n",
        "plt.plot(epochs, val_loss)\n",
        "plt.title('Loss in training and validation')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "mqfBpx1kcirn",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 89
        },
        "outputId": "2a5782cb-d86c-40f0-9820-0e6c32d6dba7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Apple___Apple_scab': 0, 'Apple___Black_rot': 1, 'Apple___Cedar_apple_rust': 2, 'Apple___healthy': 3, 'Background_without_leaves': 4, 'Blueberry___healthy': 5, 'Cherry___Powdery_mildew': 6, 'Cherry___healthy': 7, 'Corn___Cercospora_leaf_spot Gray_leaf_spot': 8, 'Corn___Common_rust': 9, 'Corn___Northern_Leaf_Blight': 10, 'Corn___healthy': 11, 'Grape___Black_rot': 12, 'Grape___Esca_(Black_Measles)': 13, 'Grape___Leaf_blight_(Isariopsis_Leaf_Spot)': 14, 'Grape___healthy': 15, 'Orange___Haunglongbing_(Citrus_greening)': 16, 'Peach___Bacterial_spot': 17, 'Peach___healthy': 18, 'Pepper,_bell___Bacterial_spot': 19, 'Pepper,_bell___healthy': 20, 'Potato___Early_blight': 21, 'Potato___Late_blight': 22, 'Potato___healthy': 23, 'Raspberry___healthy': 24, 'Soybean___healthy': 25, 'Squash___Powdery_mildew': 26, 'Strawberry___Leaf_scorch': 27, 'Strawberry___healthy': 28, 'Tomato___Bacterial_spot': 29, 'Tomato___Early_blight': 30, 'Tomato___Late_blight': 31, 'Tomato___Leaf_Mold': 32, 'Tomato___Septoria_leaf_spot': 33, 'Tomato___Spider_mites Two-spotted_spider_mite': 34, 'Tomato___Target_Spot': 35, 'Tomato___Tomato_Yellow_Leaf_Curl_Virus': 36, 'Tomato___Tomato_mosaic_virus': 37, 'Tomato___healthy': 38}\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 5). These functions will not be directly callable after loading.\n",
            "WARNING:absl:Found untraced functions such as restored_function_body, restored_function_body, restored_function_body, restored_function_body, restored_function_body while saving (showing 5 of 5). These functions will not be directly callable after loading.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_0d985e7f-5b48-4571-8868-4fdcd8cad3b1\", \"model.tflite\", 1001452)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_74ecf35b-c807-4d83-83e0-dc33e8bbbf6f\", \"labels.txt\", 942)"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "# get labels.txt and model.tflite file, to use them in the app\n",
        "\n",
        "print(train_generator.class_indices)\n",
        "labels = '\\n'.join(sorted(train_generator.class_indices.keys()))\n",
        "with open('labels.txt', 'w') as f:\n",
        "    f.write(labels)\n",
        "\n",
        "\n",
        "saved_model_dir = ''\n",
        "tf.saved_model.save(model, saved_model_dir)\n",
        "\n",
        "converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir) \n",
        "tflite_model = converter.convert()\n",
        "\n",
        "with open('model.tflite', 'wb') as f:\n",
        "  f.write(tflite_model)\n",
        "\n",
        "# download from colab\n",
        "from google.colab import files\n",
        "files.download('model.tflite')\n",
        "files.download('labels.txt')"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "collapsed_sections": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}