ImageClassifierShared.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ImageClassifierShared.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "metadata": {
        "id": "FhW8oYOi_3Nz",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Classifying apples and bananas using image Classifier**    \n",
        "\n",
        "In today's tutorial we are going to build a train an existing image classifier with addtional images to classify given fruit image as an apple or a banana. We are going to use imageAI library to train our model. If you are new to google colab just keep in mind that commands preceeded by ***!*** are run as shell commands while all other commands are run in python environment.   \n",
        "  \n",
        "Since image classification requires intensive computing resources we are going to use a GPU runtime to train our model. So first go to **'RunTime'** menu option displayed above in the menu bar and select **'Change Runtime Type'**. In the** 'Hardware accelerator'** dropdown select **'GPU'** option and click **'Save' **\n",
        "\n",
        "Next we are going to install imageAI library so select cell below and hit 'Shift + Enter' key to install imageai.\n"
      ]
    },
    {
      "metadata": {
        "id": "DQu1jkv_sWZq",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!pip3 install https://github.com/OlafenwaMoses/ImageAI/releases/download/2.0.2/imageai-2.0.2-py3-none-any.whl "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "XftY7t4mCVT4",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now we need to create directories for training our model. The **'mkdir'** command below will generate all necessary folders required for our needs based on nested object strucure passed to it."
      ]
    },
    {
      "metadata": {
        "id": "b-rypiUI-GtI",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!mkdir -p data/fruits/{train/{apple,banana},test/{apple,banana},valid}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ejM0XXnACtOS",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Let's check if folders are created properly by installing ***tree*** package and running the tree command"
      ]
    },
    {
      "metadata": {
        "id": "gKR24TyAsQSS",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!apt-get install tree\n",
        "!tree data/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ejo6-O2rDGoP",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Next we need to download subversion package which will be useful in downloading images for training and test datasets from github."
      ]
    },
    {
      "metadata": {
        "colab_type": "code",
        "id": "2Wc-FTW0shM4",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!apt-get install subversion"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "z0nxEOa9DTxi",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now let us populate training data in apple folder by downloading images from github repository by running below commands"
      ]
    },
    {
      "metadata": {
        "id": "3EqQIJSUGwEx",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "cd /content/data/fruits/train/apple/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "NSZjbyo5DhKM",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We are going to first download proper resolution images of apples from fruits images made available on github link here:-  [Fruit Image Dataset\n",
        "](https://github.com/Horea94/Fruit-Images-Dataset). Since this images are of same resolution it will allow our model to identify basic shape and attribute of apple with ease.   \n",
        "\n",
        "Here svn export command below is used to download images from a sub-folder from given github repository so that we only download apple images instead of entire repo. Next we simply move images to parent folder from temporary download folder and remove the temporary download folder. "
      ]
    },
    {
      "metadata": {
        "id": "-zH2_tZXMMAU",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!svn export https://github.com/Horea94/Fruit-Images-Dataset.git/trunk/Training/Apple%20Red%201\n",
        "!mv 'Apple Red 1'/* ./\n",
        "!rm -rf 'Apple Red 1'/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "UXDwbjqGj3u0",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We also need to add real world images with different resolutions to input dataset in order to make our model more robust in making predictions on data. In this case we are downloading data from Pixabay website using their api whose documentation is available here: [Pixabay Api](https://pixabay.com/api/docs/). This will allow us to get more real world photos in our input dataset.  \n",
        "\n",
        "In the code below we request 3 pages containing 200 results per page from pixabay api using for loop then download image images to our folder using **urlretrieve**  module from urllib library. We are storing images using their ids as names."
      ]
    },
    {
      "metadata": {
        "id": "B-Nv0VHuXIEV",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import requests\n",
        "import urllib.request\n",
        "for x in range(1, 3):  \n",
        "  response = requests.get(\"https://pixabay.com/api/?key=10623603-93416acbea978c20fa9a7a48d&q=apple+fruit&order=popular&image_type=photo&per_page=200&page={pageno}\".format(pageno=x))\n",
        "  imagesArray = response.json()[\"hits\"]\n",
        "  for imageObject in imagesArray:\n",
        "     print(\"getting file\"+str(imageObject[\"id\"])+\".jpg\")\n",
        "     urllib.request.urlretrieve(imageObject[\"previewURL\"], str(imageObject[\"id\"])+\".jpg\") \n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "xBZVpHbQkxAQ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Next we will try to visualize some of the images using **matplotlib** library just to see what kind of images we have downloaded."
      ]
    },
    {
      "metadata": {
        "id": "JQZ0KjtwK7cB",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import os\n",
        "files = os.listdir(f'./')[:7]\n",
        "files\n",
        "import matplotlib.pyplot as plt \n",
        "img = plt.imread(f'./{files[6]}')\n",
        "plt.imshow(img);"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "m36lDBySlAEb",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Next we are moving one image from downloaded ones to valid folder which will be used to validate the accuracy of our model predictions later."
      ]
    },
    {
      "metadata": {
        "id": "u6Pg-JJMWiZA",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!mv 1_100.jpg /content/data/fruits/valid/apple.jpg"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "-CQrjaMClNK-",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now we are going to run similar steps in test folder to add testing images of apples which will form a part our testing dataset."
      ]
    },
    {
      "metadata": {
        "id": "eE-2f4C2Zb9M",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e62a405c-cb23-432b-8fe0-8a6e5d2e661a"
      },
      "cell_type": "code",
      "source": [
        "cd /content/data/fruits/test/apple"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/data/fruits/test/apple\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "s6w1qKraldkk",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We are importing test images from same github project below."
      ]
    },
    {
      "metadata": {
        "id": "-6aoBnmyUtKF",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!svn export https://github.com/Horea94/Fruit-Images-Dataset.git/trunk/Test/Apple%20Red%201\n",
        "!mv 'Apple Red 1'/* ./\n",
        "!rm -rf 'Apple Red 1'/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "2h8_Th2LlmHN",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "And add some real world images to test folder too from pixabay."
      ]
    },
    {
      "metadata": {
        "id": "UztzE4zUKP4j",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "response = requests.get(\"https://pixabay.com/api/?key=10623603-93416acbea978c20fa9a7a48d&q=apple+fruit&order=popular&image_type=photo&per_page=200&page=3\")\n",
        "imagesArray = response.json()[\"hits\"]\n",
        "for imageObject in imagesArray:\n",
        "  print(\"getting file\"+str(imageObject[\"id\"])+\".jpg\")\n",
        "  urllib.request.urlretrieve(imageObject[\"previewURL\"], str(imageObject[\"id\"])+\".jpg\") "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "3vbVRPzglvsc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Next we are printing the count of total images in train and test directory."
      ]
    },
    {
      "metadata": {
        "id": "BsDpOYEEPoIB",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!echo \"Apples train directory has $(ls -l /content/data/fruits/train/apple | egrep -c '^-') files\"\n",
        "!echo \"Apples test directory has $(ls -l /content/data/fruits/test/apple | egrep -c '^-') files\"\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "kZh2EUWfl2sf",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now we will run same steps for populating banana images in train and test folder."
      ]
    },
    {
      "metadata": {
        "id": "1b8BdHjIMwv1",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "cd /content/data/fruits/train/banana"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "qjM3w5EwMx4C",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!svn export https://github.com/Horea94/Fruit-Images-Dataset.git/trunk/Training/Banana\n",
        "!mv 'Banana'/* ./\n",
        "!rm -rf 'Banana'/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "NS-As_Hv3Op6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import requests\n",
        "import urllib.request\n",
        "for x in range(1, 3):  \n",
        "  response = requests.get(\"https://pixabay.com/api/?key=10623603-93416acbea978c20fa9a7a48d&q=banana+fruit&order=popular&image_type=photo&per_page=200&page={pageno}\".format(pageno=x))\n",
        "  imagesArray = response.json()[\"hits\"]\n",
        "  for imageObject in imagesArray:\n",
        "     print(\"getting file\"+str(imageObject[\"id\"])+\".jpg\")\n",
        "     urllib.request.urlretrieve(imageObject[\"previewURL\"], str(imageObject[\"id\"])+\".jpg\") \n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "qGRu8C4eXLB2",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import os\n",
        "files = os.listdir(f'./')[:7]\n",
        "files\n",
        "import matplotlib.pyplot as plt \n",
        "img = plt.imread(f'./{files[1]}')\n",
        "plt.imshow(img);"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "snah_0ToNqA6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!mv 0_100.jpg /content/data/fruits/valid/banana.jpg"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "SgVo2mEQVY70",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "cd /content/data/fruits/test/banana"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "O8ciRHlYUVOE",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!svn export https://github.com/Horea94/Fruit-Images-Dataset.git/trunk/Test/Banana\n",
        "!mv 'Banana'/* ./\n",
        "!rm -rf 'Banana'/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "uWR7spM8YOmZ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "response = requests.get(\"https://pixabay.com/api/?key=10623603-93416acbea978c20fa9a7a48d&q=banana+fruit&order=popular&image_type=photo&per_page=200&page=3\")\n",
        "imagesArray = response.json()[\"hits\"]\n",
        "for imageObject in imagesArray:\n",
        "  print(\"getting file\"+str(imageObject[\"id\"])+\".jpg\")\n",
        "  urllib.request.urlretrieve(imageObject[\"previewURL\"], str(imageObject[\"id\"])+\".jpg\") "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JntIs9UGRh8_",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!echo \"Banana train directory has $(ls -l /content/data/fruits/train/banana | egrep -c '^-') files\"\n",
        "!echo \"Banana test directory has $(ls -l /content/data/fruits/test/banana | egrep -c '^-') files\"\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "RL5a7L2p0wcy",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "cd /content"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "7uP6aZZu1MtA",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!ls"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "yVq12AYjmWUz",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now we will perform model training steps as follows:-\n",
        "First import ModelTraining module from imageai"
      ]
    },
    {
      "metadata": {
        "id": "peRzCcFm1XIl",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from imageai.Prediction.Custom import ModelTraining"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "fYc8CfJAmi-w",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Next we set our model type to Resnet. You can find more information about Resnet here: [Medium](https://towardsdatascience.com/an-overview-of-resnet-and-its-variants-5281e2f56035)"
      ]
    },
    {
      "metadata": {
        "id": "E_nXeWZE2Oe6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "model_trainer = ModelTraining()\n",
        "model_trainer.setModelTypeAsResNet()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "RE20FR4rnWuE",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We specify data directory for our model to get input dataset images from."
      ]
    },
    {
      "metadata": {
        "id": "LP_iq3PO2Rjg",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "model_trainer.setDataDirectory(\"./data/fruits\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Lv1SNoGjnjRt",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "If you try to run the model second time then run below commands to clear data from first run before running training again."
      ]
    },
    {
      "metadata": {
        "id": "96KfHmptSU2R",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#!rm -rf data/fruits/json/\n",
        "#!rm -rf data/fruits/models/\n",
        "#!ls data/fruits/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "pqyGEBZ1nud7",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We are now all set to start training on our model using **trainModel** function below with parameters as:-   \n",
        "\n",
        "• number_objects : This refers to the number of different types of fruits in our dataset.  \n",
        "• num_experiments : This is the number of times the model trainer will study all the images in the dataset in order to achieve maximum accuracy.  \n",
        "• Enhance_data (Optional) : This is to tell the model trainer to create modified copies of the images in the dataset to ensure maximum accuracy is achieved.  \n",
        "• batch_size: This refers to the number of images the set that the model trainer will study at once, until it has studied all the images in the dataset.  \n",
        "• Show_network_summary (Optional) : This is to show the structure of the model type you are using to train the artificial intelligence model.  "
      ]
    },
    {
      "metadata": {
        "id": "vUvkFhA52You",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "model_trainer.trainModel(num_objects=2, num_experiments=10, enhance_data=False, batch_size=32, show_network_summary=True)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "kxMrzTUroX11",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Once our model has finished traning we can have a look at all the models created by running the command below. The number after **ex-** specifies training step/epoch and number after **acc-** tells us accuracy achived."
      ]
    },
    {
      "metadata": {
        "id": "-maYdz7NBjtz",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!ls /content/data/fruits/models/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "G7MqiFY1ogec",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now we will load our model to make predictions on validation data.\n",
        "First specify the model name with maximum accuracy achieved in previous set in line 4 below. For example if your model with max accuracy had name ***\"model_ex-010_acc-0.826705.h5\"*** then the setModelPath will have url ***\"./data/fruits/models/model_ex-010_acc-0.826705.h5\"***"
      ]
    },
    {
      "metadata": {
        "id": "tao0IXWfCVLL",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from imageai.Prediction.Custom import CustomImagePrediction\n",
        "prediction = CustomImagePrediction()\n",
        "prediction.setModelTypeAsResNet()\n",
        "prediction.setModelPath(\"./data/fruits/models/model_ex-010_acc-0.811080.h5\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "H5JfoMH-ppA3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now we load our model in prediction varaible with number of input object specified."
      ]
    },
    {
      "metadata": {
        "id": "CU-ZcoYQCmQQ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "prediction.setJsonPath(\"./data/fruits/json/model_class.json\")\n",
        "prediction.loadModel(num_objects=2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ebot6RggpySr",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Let us check images in our validation folder."
      ]
    },
    {
      "metadata": {
        "id": "D2SO5787VAJb",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!ls /content/data/fruits/valid"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "I5bpmr4ZqEZM",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "You can view the images by specifying filenames in below step"
      ]
    },
    {
      "metadata": {
        "id": "8HnHwYqeqJeG",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt \n",
        "img = plt.imread(f'./data/fruits/valid/apple.jpg')\n",
        "plt.imshow(img);"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "NJW0pT_kqQr4",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We will now run a prediction on the image we copied to the valid folder and print out the result to the shell below."
      ]
    },
    {
      "metadata": {
        "id": "qfPBXGhLCtrl",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "predictions, probabilities = prediction.predictImage(\"./data/fruits/valid/apple.jpg\", result_count=2)\n",
        "for eachPrediction, eachProbability in zip(predictions, probabilities):\n",
        "    print(eachPrediction , \" : \" , eachProbability)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "TrO4Id44C5YY",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "predictions, probabilities = prediction.predictImage(\"./data/fruits/valid/banana.jpg\", result_count=2)\n",
        "\n",
        "for eachPrediction, eachProbability in zip(predictions, probabilities):\n",
        "    print(eachPrediction , \" : \" , eachProbability)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Yd3iIMSVqj6N",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Let us check if our model works on image of apple fruit downloaded from internet below."
      ]
    },
    {
      "metadata": {
        "id": "I2RjuD7mhAAH",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "!wget \"https://images.pexels.com/photos/102104/pexels-photo-102104.jpeg\" -O /content/data/fruits/valid/applereal.jpg"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "rcjPpD-EquhJ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "predictions, probabilities = prediction.predictImage(\"./data/fruits/valid/applereal.jpg\", result_count=2)\n",
        "\n",
        "for eachPrediction, eachProbability in zip(predictions, probabilities):\n",
        "    print(eachPrediction , \" : \" , eachProbability)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "UpH2vyw-zdCt",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "And that concludes our today's tutorial on training an existing image classifier to classify custom images. In case you would like to experiment a bit, you can add your own custom images of different kinds and test the accuracy of predictions made by the model. Happy coding :D"
      ]
    }
  ]
}