site/en/hub/tutorials/cropnet_cassava.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vtNtfcHHoHNP"
      },
      "outputs": [],
      "source": [
        "# Copyright 2019 The TensorFlow Hub Authors. All Rights Reserved.\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",
        "# =============================================================================="
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jZwnHZ70oUIM"
      },
      "source": [
        "# CropNet: Cassava Disease Detection"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6sg9wHP9oR3q"
      },
      "source": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://www.tensorflow.org/hub/tutorials/cropnet_cassava\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />View on TensorFlow.org</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/hub/tutorials/cropnet_cassava.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://github.com/tensorflow/docs/blob/master/site/en/hub/tutorials/cropnet_cassava.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View on GitHub</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a href=\"https://storage.googleapis.com/tensorflow_docs/docs/site/en/hub/tutorials/cropnet_cassava.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\" />Download notebook</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a href=\"https://tfhub.dev/google/cropnet/classifier/cassava_disease_V1/2\"><img src=\"https://www.tensorflow.org/images/hub_logo_32px.png\" />See TF Hub model</a>\n",
        "  </td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "grEgSWu2iTxm"
      },
      "source": [
        "This notebook shows how to use the CropNet [cassava disease classifier](https://tfhub.dev/google/cropnet/classifier/cassava_disease_V1/2) model from **TensorFlow Hub**. The model classifies images of cassava leaves into one of 6 classes: *bacterial blight, brown streak disease, green mite, mosaic disease, healthy, or unknown*.\n",
        "\n",
        "This colab demonstrates how to:\n",
        " * Load the https://tfhub.dev/google/cropnet/classifier/cassava_disease_V1/2 model from **TensorFlow Hub**\n",
        " * Load the [cassava](https://www.tensorflow.org/datasets/catalog/cassava) dataset from **TensorFlow Datasets (TFDS)**\n",
        " * Classify images of cassava leaves into 4 distinct cassava disease categories or as healthy or unknown.\n",
        " * Evaluate the *accuracy* of the classifier and look at how *robust* the model is  when applied to out of domain images."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bKn4Fiq2OD7u"
      },
      "source": [
        "## Imports and setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LMgjpSoYqJIz"
      },
      "outputs": [],
      "source": [
        "!pip install matplotlib==3.2.2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "both",
        "id": "FIP4rkjp45MG"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import tensorflow as tf\n",
        "import tensorflow_datasets as tfds\n",
        "import tensorflow_hub as hub"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "mIqmq_qmWw78"
      },
      "outputs": [],
      "source": [
        "#@title Helper function for displaying examples\n",
        "def plot(examples, predictions=None):\n",
        "  # Get the images, labels, and optionally predictions\n",
        "  images = examples['image']\n",
        "  labels = examples['label']\n",
        "  batch_size = len(images)\n",
        "  if predictions is None:\n",
        "    predictions = batch_size * [None]\n",
        "\n",
        "  # Configure the layout of the grid\n",
        "  x = np.ceil(np.sqrt(batch_size))\n",
        "  y = np.ceil(batch_size / x)\n",
        "  fig = plt.figure(figsize=(x * 6, y * 7))\n",
        "\n",
        "  for i, (image, label, prediction) in enumerate(zip(images, labels, predictions)):\n",
        "    # Render the image\n",
        "    ax = fig.add_subplot(x, y, i+1)\n",
        "    ax.imshow(image, aspect='auto')\n",
        "    ax.grid(False)\n",
        "    ax.set_xticks([])\n",
        "    ax.set_yticks([])\n",
        "\n",
        "    # Display the label and optionally prediction\n",
        "    x_label = 'Label: ' + name_map[class_names[label]]\n",
        "    if prediction is not None:\n",
        "      x_label = 'Prediction: ' + name_map[class_names[prediction]] + '\\n' + x_label\n",
        "      ax.xaxis.label.set_color('green' if label == prediction else 'red')\n",
        "    ax.set_xlabel(x_label)\n",
        "\n",
        "  plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kwrg9yIlaUSb"
      },
      "source": [
        "## Dataset\n",
        "\n",
        "Let's load the *cassava* dataset from TFDS"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0rTcnxoSkp31"
      },
      "outputs": [],
      "source": [
        "dataset, info = tfds.load('cassava', with_info=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GpC71TFDhJFO"
      },
      "source": [
        "Let's take a look at the dataset info to learn more about it, like the description and citation and information about how many examples are available"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "btJBMovmbYtR"
      },
      "outputs": [],
      "source": [
        "info"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QT3XWAtR6BRy"
      },
      "source": [
        "The *cassava* dataset has images of cassava leaves with 4 distinct diseases as well as healthy cassava leaves. The model can predict all of these classes as well as sixth class for \"unknown\" when the model is not confident in its prediction."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9NT9q8yyXZfX"
      },
      "outputs": [],
      "source": [
        "# Extend the cassava dataset classes with 'unknown'\n",
        "class_names = info.features['label'].names + ['unknown']\n",
        "\n",
        "# Map the class names to human readable names\n",
        "name_map = dict(\n",
        "    cmd='Mosaic Disease',\n",
        "    cbb='Bacterial Blight',\n",
        "    cgm='Green Mite',\n",
        "    cbsd='Brown Streak Disease',\n",
        "    healthy='Healthy',\n",
        "    unknown='Unknown')\n",
        "\n",
        "print(len(class_names), 'classes:')\n",
        "print(class_names)\n",
        "print([name_map[name] for name in class_names])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I6y_MGxgiW09"
      },
      "source": [
        "Before we can feed the data to the model, we need to do a bit of preprocessing. The model expects 224 x 224 images with RGB channel values in [0, 1]. Let's normalize and resize the images."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UxtxvqRjh7Nm"
      },
      "outputs": [],
      "source": [
        "def preprocess_fn(data):\n",
        "  image = data['image']\n",
        "\n",
        "  # Normalize [0, 255] to [0, 1]\n",
        "  image = tf.cast(image, tf.float32)\n",
        "  image = image / 255.\n",
        "\n",
        "  # Resize the images to 224 x 224\n",
        "  image = tf.image.resize(image, (224, 224))\n",
        "\n",
        "  data['image'] = image\n",
        "  return data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qz27YrZahdvn"
      },
      "source": [
        "Let's take a look at a few examples from the dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j6LkAxv3f-aJ"
      },
      "outputs": [],
      "source": [
        "batch = dataset['validation'].map(preprocess_fn).batch(25).as_numpy_iterator()\n",
        "examples = next(batch)\n",
        "plot(examples)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eHlEAhL3hq2R"
      },
      "source": [
        "## Model\n",
        "\n",
        "Let's load the classifier from TF Hub and get some predictions and see the predictions of the model is on a few examples"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b6eIWkTjIQhS"
      },
      "outputs": [],
      "source": [
        "classifier = hub.KerasLayer('https://tfhub.dev/google/cropnet/classifier/cassava_disease_V1/2')\n",
        "probabilities = classifier(examples['image'])\n",
        "predictions = tf.argmax(probabilities, axis=-1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MTQA1YAltfRZ"
      },
      "outputs": [],
      "source": [
        "plot(examples, predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MuFE8A5aZv9z"
      },
      "source": [
        "## Evaluation & robustness\n",
        "\n",
        "Let's measure the *accuracy* of our classifier on a split of the dataset. We can also look at the *robustness* of the model by evaluating its performance on a non-cassava dataset. For image of other plant datasets like iNaturalist or beans, the model should almost always return *unknown*."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "0ERcNxs0kHd3"
      },
      "outputs": [],
      "source": [
        "#@title Parameters {run: \"auto\"}\n",
        "\n",
        "DATASET = 'cassava'  #@param {type:\"string\"} ['cassava', 'beans', 'i_naturalist2017']\n",
        "DATASET_SPLIT = 'test' #@param {type:\"string\"} ['train', 'test', 'validation']\n",
        "BATCH_SIZE =  32 #@param {type:\"integer\"}\n",
        "MAX_EXAMPLES = 1000 #@param {type:\"integer\"}\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Mt0-IVmZplbb"
      },
      "outputs": [],
      "source": [
        "def label_to_unknown_fn(data):\n",
        "  data['label'] = 5  # Override label to unknown.\n",
        "  return data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cQYvY3IvY2Nx"
      },
      "outputs": [],
      "source": [
        "# Preprocess the examples and map the image label to unknown for non-cassava datasets.\n",
        "ds = tfds.load(DATASET, split=DATASET_SPLIT).map(preprocess_fn).take(MAX_EXAMPLES)\n",
        "dataset_description = DATASET\n",
        "if DATASET != 'cassava':\n",
        "  ds = ds.map(label_to_unknown_fn)\n",
        "  dataset_description += ' (labels mapped to unknown)'\n",
        "ds = ds.batch(BATCH_SIZE)\n",
        "\n",
        "# Calculate the accuracy of the model\n",
        "metric = tf.keras.metrics.Accuracy()\n",
        "for examples in ds:\n",
        "  probabilities = classifier(examples['image'])\n",
        "  predictions = tf.math.argmax(probabilities, axis=-1)\n",
        "  labels = examples['label']\n",
        "  metric.update_state(labels, predictions)\n",
        "\n",
        "print('Accuracy on %s: %.2f' % (dataset_description, metric.result().numpy()))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rvS18sBExpdL"
      },
      "source": [
        "## Learn more\n",
        "\n",
        "* Learn more about the model on TensorFlow Hub: https://tfhub.dev/google/cropnet/classifier/cassava_disease_V1/2\n",
        "* Learn how to build a custom image classifier running on a mobile phone with [ML Kit](https://developers.google.com/ml-kit/custom-models#tfhub) with the [TensorFlow Lite version of this model](https://tfhub.dev/google/lite-model/cropnet/classifier/cassava_disease_V1/1)."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "name": "cropnet_cassava.ipynb",
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}