{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "QquaYpB00hfs" }, "source": [ "[](http://edenlibrary.ai/)" ] }, { "cell_type": "markdown", "metadata": { "id": "yp-OgP370hft" }, "source": [ "## Instructions\n", "To run any of Eden's notebooks, please check the guides on our [Wiki page](https://github.com/Eden-Library-AI/eden_library_notebooks/wiki).
\n", "There you will find instructions on how to deploy the notebooks on [your local system](https://github.com/Eden-Library-AI/eden_library_notebooks/wiki/Deploy-Notebooks-Locally), on [Google Colab](https://github.com/Eden-Library-AI/eden_library_notebooks/wiki/Deploy-Notebooks-on-GColab), or on [MyBinder](https://github.com/Eden-Library-AI/eden_library_notebooks/wiki/Deploy-Notebooks-on-MyBinder), as well as other useful links, troubleshooting tips, and more.
\n", "For this notebook you will need to download the **Cotton-100619-Healthy-zz-V1-20210225102300**, **Black nightsade-220519-Weed-zz-V1-20210225102034**, **Tomato-240519-Healthy-zz-V1-20210225103740** and **Velvet leaf-220519-Weed-zz-V1-20210225104123** datasets from [Eden Library](https://edenlibrary.ai/datasets), and you may want to use the **eden_pytorch_transfer_learning.yml** file to recreate a suitable conda environment.\n", "\n", "**Note:** If you find any issues while executing the notebook, don't hesitate to open an issue on Github. We will try to reply as soon as possible." ] }, { "cell_type": "markdown", "metadata": { "id": "dwqUKc-L0hft" }, "source": [ "## Background\n", "\n", "Open Neural Network Exchange ONNX provides an open source format for AI models, both deep learning and traditional ML. It defines an extensible computation graph model, as well as definitions of built-in operators and standard data types. \n", "\n", "ONNX is widely supported and can be found in many frameworks, tools, and hardware. Enabling interoperability between different frameworks and streamlining the path from research to production helps increase the speed of innovation in the AI community\n", "\n", "ONNX Runtime is a performance-focused engine for ONNX models, which inferences efficiently across multiple platforms and hardware (Windows, Linux, and Mac and on both CPUs and GPUs). ONNX Runtime has proved to considerably increase performance over multiple models.\n", "\n", "For this tutorial, you will need to install ONNX and ONNX Runtime. You can get binary builds of ONNX and ONNX Runtime with pip install onnx onnxruntime. Note that ONNX Runtime is compatible with Python versions 3.5 to 3.7.\n", "\n", "In this notebook we are going to make use of ONNX format and export our model from PyTorch to ONNX. Furthermore, we are going to use onnnxruntime to run inference.\n", "\n", "In this notebook, we are going to cover a technique called **Transfer Learning**, which generally refers to a process where a machine learning model is trained on one problem, and afterwards, it is reused in some way on a second (possibly) related problem (Bengio, 2012). Specifically, in **deep learning**, this technique is used by training only some layers of the pre-trained network. Its promise is that the training will be more efficient and in the best of the cases the performance will be better compared to a model trained from scratch. In this example we are using ResNet architecture and the PyTorch framework.\n", "\n", "It is important to note that in this notebook, inspite of making use of ONNX, we are also using the PyTorch framework to design and train our neural networks. This represents an extension over the previous Eden notebooks:\n", "1. https://github.com/Eden-Library-AI/eden_library_notebooks/blob/master/image_classification/weeds_identification-transfer_learning-1.ipynb\n", "2. https://github.com/Eden-Library-AI/eden_library_notebooks/blob/master/image_classification/weeds_identification-transfer_learning-2.ipynb\n", "3. https://github.com/Eden-Library-AI/eden_library_notebooks/blob/master/image_classification/weeds_identification-transfer_learning-3.ipynb\n", "4. https://github.com/Eden-Library-AI/eden_library_notebooks/blob/master/image_classification/weeds_identification-transfer_learning-4.ipynb\n", "5. https://github.com/Eden-Library-AI/eden_library_notebooks/blob/master/image_classification/weeds_identification-transfer_learning-5.ipynb" ] }, { "cell_type": "markdown", "metadata": { "id": "HEZ1kYtlIJIf" }, "source": [ "### Importing Libraries" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "collapsed": true, "id": "hhJqeMkfivXv", "jupyter": { "outputs_hidden": true }, "outputId": "903c1b7e-6bac-4fdb-a3ba-7817a907f8b0", "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n", "Collecting onnx\n", " Downloading onnx-1.9.0-cp38-cp38-manylinux2010_x86_64.whl (12.2 MB)\n", "\u001b[K |████████████████████████████████| 12.2 MB 3.2 MB/s eta 0:00:01\n", "\u001b[?25hRequirement already satisfied: numpy>=1.16.6 in /home/air/anaconda3/envs/eden_pytorch_transfer/lib/python3.8/site-packages (from onnx) (1.20.2)\n", "Requirement already satisfied: typing-extensions>=3.6.2.1 in /home/air/anaconda3/envs/eden_pytorch_transfer/lib/python3.8/site-packages (from onnx) (3.7.4.3)\n", "Collecting protobuf\n", " Downloading protobuf-3.17.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl (1.0 MB)\n", "\u001b[K |████████████████████████████████| 1.0 MB 3.4 MB/s eta 0:00:01\n", "\u001b[?25hRequirement already satisfied: six in /home/air/anaconda3/envs/eden_pytorch_transfer/lib/python3.8/site-packages (from onnx) (1.15.0)\n", "Installing collected packages: protobuf, onnx\n", "Successfully installed onnx-1.9.0 protobuf-3.17.3\n", "Looking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n", "Collecting onnxruntime\n", " Downloading onnxruntime-1.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.5 MB)\n", "\u001b[K |████████████████████████████████| 4.5 MB 2.7 MB/s eta 0:00:01\n", "\u001b[?25hRequirement already satisfied: protobuf in /home/air/anaconda3/envs/eden_pytorch_transfer/lib/python3.8/site-packages (from onnxruntime) (3.17.3)\n", "Collecting flatbuffers\n", " Downloading flatbuffers-2.0-py2.py3-none-any.whl (26 kB)\n", "Requirement already satisfied: numpy>=1.16.6 in /home/air/anaconda3/envs/eden_pytorch_transfer/lib/python3.8/site-packages (from onnxruntime) (1.20.2)\n", "Requirement already satisfied: six>=1.9 in /home/air/anaconda3/envs/eden_pytorch_transfer/lib/python3.8/site-packages (from protobuf->onnxruntime) (1.15.0)\n", "Installing collected packages: flatbuffers, onnxruntime\n", "Successfully installed flatbuffers-2.0 onnxruntime-1.8.0\n" ] } ], "source": [ "# In case it is not installed in your system run pip installs ( Google Colab doesn't have onnx by default)\n", "!pip install onnx\n", "!pip install onnxruntime" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "Xvqku2sVIO0s" }, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "from torch.optim import lr_scheduler\n", "import torchvision\n", "from torchvision import datasets, models, transforms\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import time\n", "import os\n", "import copy\n", "import random\n", "import shutil\n", "\n", "# onnx necessary packages\n", "import torch.onnx\n", "import onnx\n", "import onnxruntime\n", "\n", "plt.ion() # interactive mode" ] }, { "cell_type": "markdown", "metadata": { "id": "-zO6c2eoAvt_" }, "source": [ "### Folder structuring \n", "We are going to create a main data folder 'eden_data' that will contain the 4 different datasets. We will also split the datasets into train and validation sub-sets. " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "LxFPCQ91iatm" }, "outputs": [], "source": [ "# Change this path to correspong to your system. It needs to point to your eden-library-datasets folder \n", "\n", "DATA_PATH = '/home/air/Desktop/EDEN-REPO/eden_library_notebooks/eden-library-datasets'" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "hMp60uWfULoe", "outputId": "991765e0-12af-47a0-ed0c-0c26f2ec34f0" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Moved DSC_0514.JPG to validation images\n", "Moved DSC_0536.JPG to validation images\n", "Moved DSC_0741.JPG to validation images\n", "Moved DSC_0504.JPG to validation images\n", "Moved DSC_0501.JPG to validation images\n", "Moved DSC_0553.JPG to validation images\n", "Moved DSC_0532.JPG to validation images\n", "Moved DSC_0726.JPG to validation images\n", "Moved DSC_0740.JPG to validation images\n", "Moved DSC_0516.JPG to validation images\n", "Moved DSC_0550.JPG to validation images\n", "Moved DSC_0528.JPG to validation images\n", "Moved DSC_0506.JPG to validation images\n", "Moved DSC_0717.JPG to validation images\n", "Moved DSC_0628.JPG to validation images\n", "Moved DSC_0508.JPG to validation images\n", "Moved DSC_0517.JPG to validation images\n", "Moved DSC_0538.JPG to validation images\n", "Moved DSC_0711.JPG to validation images\n", "Moved DSC_0723.JPG to validation images\n", "Moved DSC_0646.JPG to validation images\n", "Moved DSC_0567.JPG to validation images\n", "Moved DSC_0500.JPG to validation images\n", "Moved DSC_0551.JPG to validation images\n", "Moved DSC_0689.JPG to validation images\n", "Moved DSC_0787.JPG to validation images\n", "Moved DSC_0828.JPG to validation images\n", "Moved DSC_0247.JPG to validation images\n", "Moved DSC_0195.JPG to validation images\n", "Moved DSC_0215.JPG to validation images\n", "Moved DSC_0259.JPG to validation images\n", "Moved DSC_0204.JPG to validation images\n", "Moved DSC_0268.JPG to validation images\n", "Moved DSC_0205.JPG to validation images\n", "Moved DSC_0795.JPG to validation images\n", "Moved DSC_0278.JPG to validation images\n", "Moved DSC_0203.JPG to validation images\n", "Moved DSC_0253.JPG to validation images\n", "Moved DSC_0210.JPG to validation images\n", "Moved DSC_0312.JPG to validation images\n", "Moved DSC_0817.JPG to validation images\n", "Moved DSC_0212.JPG to validation images\n", "Moved DSC_0230.JPG to validation images\n", "Moved DSC_0246.JPG to validation images\n", "Moved DSC_0326.JPG to validation images\n", "Moved DSC_0805.JPG to validation images\n", "Moved DSC_0315.JPG to validation images\n", "Moved DSC_0301.JPG to validation images\n", "Moved DSC_0832.JPG to validation images\n", "Moved DSC_0257.JPG to validation images\n", "Moved DSC_0280.JPG to validation images\n", "Moved DSC_0809.JPG to validation images\n", "Moved DSC_0792.JPG to validation images\n", "Moved DSC_0199.JPG to validation images\n", "Moved DSC_0813.JPG to validation images\n", "Moved DSC_0783.JPG to validation images\n", "Moved DSC_0273.JPG to validation images\n", "Moved DSC_0281.JPG to validation images\n", "Moved DSC_0272.JPG to validation images\n", "Moved DSC_0310.JPG to validation images\n", "Moved DSC_0261.JPG to validation images\n", "Moved DSC_0294.JPG to validation images\n", "Moved DSC_0250.JPG to validation images\n", "Moved DSC_0789.JPG to validation images\n", "Moved DSC_0798.JPG to validation images\n", "Moved DSC_0672.JPG to validation images\n", "Moved DSC_0651.JPG to validation images\n", "Moved DSC_0673.JPG to validation images\n", "Moved DSC_0666.JPG to validation images\n", "Moved DSC_0681.JPG to validation images\n", "Moved DSC_0663.JPG to validation images\n", "Moved DSC_0654.JPG to validation images\n", "Moved DSC_0635.JPG to validation images\n", "Moved DSC_0653.JPG to validation images\n", "Moved DSC_0583.JPG to validation images\n", "Moved DSC_0486.JPG to validation images\n", "Moved DSC_0642.JPG to validation images\n", "Moved DSC_0610 - Copy.JPG to validation images\n", "Moved DSC_0607.JPG to validation images\n", "Moved DSC_0493.JPG to validation images\n", "Moved DSC_0737.JPG to validation images\n", "Moved DSC_0638.JPG to validation images\n", "Moved DSC_0498.JPG to validation images\n", "Moved DSC_0705.JPG to validation images\n", "Moved DSC_0644.JPG to validation images\n", "Moved DSC_0562.JPG to validation images\n", "Moved DSC_0612 - Copy.JPG to validation images\n", "Moved DSC_0608.JPG to validation images\n", "Moved DSC_0619.JPG to validation images\n", "Moved DSC_0617.JPG to validation images\n", "Moved DSC_0708.JPG to validation images\n", "Moved DSC_0580.JPG to validation images\n", "Moved DSC_0743.JPG to validation images\n", "Moved DSC_0611.JPG to validation images\n", "Moved DSC_0728.JPG to validation images\n", "Moved DSC_0609.JPG to validation images\n", "Moved DSC_0489.JPG to validation images\n", "Moved DSC_0606 - Copy.JPG to validation images\n", "Moved DSC_0602.JPG to validation images\n", "Moved DSC_0579.JPG to validation images\n" ] } ], "source": [ "## WARNING : This cell script will Move the 4 datasets used here from your eden-library-datasets directory and put them to a new one created for this particular dataset. \n", "# Your initial eden-library-datasets will not contain the 4 datasets used here after the script. \n", "\n", "# Change paths to suit your system (this was created for google colab)\n", "if not os.path.exists(DATA_PATH) :\n", " os.makedirs(DATA_PATH)\n", "# Directory that will contain all of the data needed for training\n", "notebook_dataset = os.path.join(DATA_PATH, 'pytorch-onnx')\n", "\n", "# Create train and val folders that will host the data.\n", "train_path = os.path.join(notebook_dataset, 'train')\n", "if not os.path.exists(train_path):\n", " os.makedirs(train_path)\n", "val_path = os.path.join(notebook_dataset, 'val')\n", "if not os.path.exists(val_path):\n", " os.makedirs(val_path)\n", "\n", "# names of the datasets we are going to use \n", "classes = [\"Black nightsade-220519-Weed-zz-V1-20210225102034\", \"Tomato-240519-Healthy-zz-V1-20210225103740\", \n", " \"Cotton-100619-Healthy-zz-V1-20210225102300\", \"Velvet leaf-220519-Weed-zz-V1-20210225104123\"]\n", "num_classes = len(classes) # we will need this later\n", "for class_name in classes:\n", " # Path to source folders\n", " class_path = DATA_PATH + os.path.sep + class_name\n", "\n", " # Create subfolder for each class in validation folder\n", " class_val_path = val_path + os.path.sep + class_name\n", " os.mkdir(class_val_path)\n", " # Move original folder to train folder, created above\n", " class_train_path = train_path + os.path.sep + class_name\n", " shutil.move(class_path, train_path)\n", "\n", " # List of all files\n", " images = os.listdir(class_train_path)\n", "\n", " # Splitting randomly, choosing some files for validation.\n", " valid_images = random.sample(\n", " images, (int(round(len(images) * 0.2)))\n", " ) # Change ' *0.1 ' to whatever train-test split value you want\n", " # Move validation images to validation folder\n", " for val_image in valid_images:\n", " shutil.move(\n", " class_train_path + os.path.sep + val_image,\n", " class_val_path + os.path.sep + val_image,\n", " )\n", " print(\"Moved \", val_image, \" to validation images\")" ] }, { "cell_type": "markdown", "metadata": { "id": "TSz6HE1Fvj_2" }, "source": [ "### Auxiliar functions " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "PAE-Uq355fpL" }, "outputs": [], "source": [ "\"\"\"Training function. Train input model based on the parameters given.\n", " Input:\n", " model: model to train\n", " criterion: loss function to be used for training \n", " optimizer: optimizer \n", " scheduler: learning rate scheduler\n", " num_epochs: number of training epochs\n", "\n", " Returns: Trained model\n", " \n", "\"\"\"\n", "\n", "\n", "def train_model(model, criterion, optimizer, scheduler, num_epochs=50):\n", " since = time.time()\n", " best_model = copy.deepcopy(model.state_dict())\n", " best_acc = 0.0\n", "\n", " for epoch in range(num_epochs):\n", " print(\"Epoch {}/{}\".format(epoch, num_epochs - 1))\n", " print(\"-\" * 10)\n", "\n", " # Each epoch has a training and a validation phase\n", " for phase in [\"train\", \"val\"]:\n", " if phase == \"train\":\n", " model.train() # Set model to training mode\n", " else:\n", " model.eval() # Set model to evaluation mode\n", "\n", " # Reset loss\n", " running_loss = 0.0\n", " running_corrects = 0\n", "\n", " # Iterate over data\n", " for inputs, labels in dataloaders[phase]:\n", " inputs = inputs.to(device)\n", " labels = labels.to(device)\n", "\n", " # zero the parameters gradients\n", " optimizer.zero_grad()\n", "\n", " # forward\n", " # track history if only in train\n", " with torch.set_grad_enabled(phase == \"train\"):\n", " outputs = model(inputs)\n", " _, preds = torch.max(outputs, 1)\n", " loss = criterion(outputs, labels)\n", "\n", " # backward pass + optimize only if in training phase\n", " if phase == \"train\":\n", " loss.backward()\n", " optimizer.step()\n", "\n", " # statistics\n", " running_loss += loss.item() * inputs.size(0)\n", " running_corrects += torch.sum(preds == labels.data)\n", " if phase == \"train\":\n", " scheduler.step()\n", "\n", " epoch_loss = running_loss / dataset_sizes[phase]\n", " epoch_acc = running_corrects.double() / dataset_sizes[phase]\n", "\n", " print(\"{} Loss: {:.4f} Acc: {:.4f}\".format(phase, epoch_loss, epoch_acc))\n", "\n", " # deep copy the model\n", " if phase == \"val\" and epoch_acc > best_acc:\n", " best_acc = epoch_acc\n", " best_model_wts = copy.deepcopy(model.state_dict())\n", "\n", " print()\n", "\n", " time_elapsed = time.time() - since\n", " print(\n", " \"Training complete in {:.0f}m {:.0f}s\".format(\n", " time_elapsed // 60, time_elapsed % 60\n", " )\n", " )\n", " print(\"Best val Acc: {:4f}\".format(best_acc))\n", "\n", " # load best model weights\n", " model.load_state_dict(best_model_wts)\n", " return model" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "fiSNg6MJarNj" }, "outputs": [], "source": [ "\"\"\"\n", "Runs inference on a defined number of images with the specified model. Plots the images with the model's predictions. \n", " Input:\n", " model : model to run inference with\n", " num_images : number of validation set images to make predictions on \n", "\n", " Returns : Plotted images and predictions\n", "\"\"\"\n", "\n", "\n", "def visualize_predictions(model, num_images=6):\n", " was_training = model.training\n", " model.eval()\n", " images_so_far = 0\n", " fig = plt.figure()\n", "\n", " with torch.no_grad():\n", " for i, (inputs, labels) in enumerate(dataloaders[\"val\"]):\n", " inputs = inputs.to(device)\n", " labels = labels.to(device)\n", "\n", " outputs = model(inputs)\n", " _, preds = torch.max(outputs, 1)\n", "\n", " for j in range(inputs.size()[0]):\n", " images_so_far += 1\n", " ax = plt.subplot(num_images // 2, 2, images_so_far)\n", " ax.axis(\"off\")\n", " ax.set_title(\n", " \"predicted: {} with\".format(class_names[preds[j]])\n", " + \" Actual class: {}\".format(class_names[labels[j]])\n", " )\n", " imshow(inputs.cpu().data[j])\n", "\n", " if images_so_far == num_images:\n", " model.train(mode=was_training)\n", " return\n", " model.train(mode=was_training)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "RmhCuICPg9os" }, "outputs": [], "source": [ "\"\"\"\n", "Plot images\n", "\"\"\"\n", "\n", "\n", "def imshow(inp, title=None):\n", " \"\"\"Imshow for Tensor.\"\"\"\n", " inp = inp.numpy().transpose((1, 2, 0))\n", " mean = np.array([0.485, 0.456, 0.406])\n", " std = np.array([0.229, 0.224, 0.225])\n", " inp = std * inp + mean\n", " inp = np.clip(inp, 0, 1)\n", " plt.imshow(inp)\n", " if title is not None:\n", " plt.title(title)\n", " plt.pause(0.001) # pause a bit so that plots are updated" ] }, { "cell_type": "markdown", "metadata": { "id": "qb7d5siZIpuw" }, "source": [ "### Data loading and augmentation\n", "\n", "First we need to load our data into our pipeline. Since our dataset is not very big we are going to apply some data augmentation in order to increase the generalization power of the network. Lastly, we are going to normalize our training and validation data for better performance and accuracy.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "E_iZOQTFJOp6" }, "outputs": [], "source": [ "# Defining some Augmentation techniques\n", "data_transforms = {\n", " # We are going to use Compose,in order to chain together multiple transformations\n", " \"train\": transforms.Compose(\n", " [\n", " transforms.RandomResizedCrop((224, 224)),\n", " transforms.RandomHorizontalFlip(),\n", " # Converting images to tensors. PyTorch needs input in tensor form.\n", " transforms.ToTensor(),\n", " # Normalizing inputs, these values are porposed by pytorch for ResNet\n", " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n", " ]\n", " ),\n", " \"val\": transforms.Compose(\n", " [\n", " transforms.Resize((224, 224)),\n", " transforms.CenterCrop(224),\n", " # Converting images to tensors. PyTorch needs input in tensor form.\n", " transforms.ToTensor(),\n", " # Normalizing inputs, these values are porposed by pytorch for ResNet\n", " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n", " ]\n", " ),\n", "}" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "p9d715AFOdRQ", "outputId": "3856a9ab-bcfa-48b0-c75a-3129955e88c2" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Class names : ['Black nightsade-220519-Weed-zz-V1-20210225102034', 'Cotton-100619-Healthy-zz-V1-20210225102300', 'Tomato-240519-Healthy-zz-V1-20210225103740', 'Velvet leaf-220519-Weed-zz-V1-20210225104123']\n", "Dataset_sizes : {'train': 399, 'val': 100}\n" ] } ], "source": [ "# Loading the datasets\n", "data_dir = notebook_dataset\n", "image_datasets = {\n", " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n", " for x in [\"train\", \"val\"]\n", "}\n", "\n", "dataloaders = {\n", " x: torch.utils.data.DataLoader(\n", " image_datasets[x], batch_size=4, shuffle=True, num_workers=1\n", " )\n", " for x in [\"train\", \"val\"]\n", "}\n", "\n", "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n", "class_names = image_datasets[\"train\"].classes\n", "print(\"Class names :\", class_names)\n", "print(\"Dataset_sizes : \", dataset_sizes)\n", "# Setting up device either cuda GPU or CPU\n", "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" ] }, { "cell_type": "markdown", "metadata": { "id": "5S0_-SbgCPx7" }, "source": [ "#### Visualizing some of the augmented training data" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 166 }, "id": "yeFgaKIkyVrG", "outputId": "b27464de-9c5b-4710-cfd8-c96d0e569f47" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Images' size: torch.Size([4, 3, 224, 224])\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" } ], "source": [ "# Get a batch of training data\n", "inputs, classes = next(iter(dataloaders[\"train\"]))\n", "print(\"Images' size: \", inputs.size())\n", "# Make a grid from batch\n", "out = torchvision.utils.make_grid(inputs)\n", "\n", "imshow(out, title=[class_names[x] for x in classes])" ] }, { "cell_type": "markdown", "metadata": { "id": "bk01UM6jl9pi" }, "source": [ "### Preparing Resnet as a feature exctractor " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 143, "referenced_widgets": [ "8058e4f2252f43b3bfc80a843d617905", "597e590352c143f7bd3d45a30d72ea88", "a6390e52137a49ee9d981268a9cb3d68", "516ed6a3704249d580b9ff66f442d834", "2ea2870da6584c60bc33c66bd5077719", "b190165fbff149b69b490ca8ffa437b9", "5fa532133b1e4b4e9656c83ab4b00d2d", "ef6fe6f2b0534b9a8099562868e71f87" ] }, "id": "Vtt3gA0mmGY0", "outputId": "531a8bc9-ee10-4500-d9b6-979d442b3990" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Num of features : 512\n", "Adjusting learning rate of group 0 to 1.0000e-03.\n" ] } ], "source": [ "# Loading Resnet through torchvision API with pretrained weights.\n", "conv_net = torchvision.models.resnet18(pretrained=True)\n", "# Freeze parameters so that their gradients are not computed in backward propagation.\n", "for param in conv_net.parameters():\n", " param.requires_grad = False\n", "\n", "# Reshaping the last layers of the Network\n", "num_ftrs = conv_net.fc.in_features\n", "print(\"Num of features :\", num_ftrs)\n", "\n", "# This is a manual process, check\n", "# https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html for more details.\n", "num_classes = 4\n", "# Adding a Fully Connected layer on top of the pretrained network\n", "conv_net.fc = nn.Linear(num_ftrs, num_classes)\n", "\n", "# Moving computations to GPU\n", "conv_net = conv_net.to(device)\n", "\n", "# Defining loss function to be used on training\n", "criterion = nn.CrossEntropyLoss()\n", "# Optimize only the final layers\n", "optimizer = optim.SGD(conv_net.fc.parameters(), lr=0.001, momentum=0.9)\n", "# Decay Lr by a factor of 0.1 every 10 epochs\n", "exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1, verbose=True)" ] }, { "cell_type": "markdown", "metadata": { "id": "smXlWVwnAm-H" }, "source": [ "### Call training" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ghiFp3tyAmkA", "outputId": "fd866179-a855-448c-f97f-9147578df8ff" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 0/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-03.\n", "train Loss: 1.2371 Acc: 0.5088\n", "val Loss: 0.7453 Acc: 0.6800\n", "\n", "Epoch 1/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-03.\n", "train Loss: 0.9323 Acc: 0.6190\n", "val Loss: 0.5919 Acc: 0.7800\n", "\n", "Epoch 2/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-03.\n", "train Loss: 0.6292 Acc: 0.7318\n", "val Loss: 0.5564 Acc: 0.7700\n", "\n", "Epoch 3/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-03.\n", "train Loss: 0.5477 Acc: 0.7895\n", "val Loss: 0.5064 Acc: 0.8300\n", "\n", "Epoch 4/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-03.\n", "train Loss: 0.6696 Acc: 0.7293\n", "val Loss: 0.3128 Acc: 0.8500\n", "\n", "Epoch 5/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-03.\n", "train Loss: 0.5818 Acc: 0.7644\n", "val Loss: 0.4980 Acc: 0.7900\n", "\n", "Epoch 6/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-03.\n", "train Loss: 0.5619 Acc: 0.7920\n", "val Loss: 0.6248 Acc: 0.7500\n", "\n", "Epoch 7/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-03.\n", "train Loss: 0.5491 Acc: 0.8120\n", "val Loss: 0.5920 Acc: 0.8100\n", "\n", "Epoch 8/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-03.\n", "train Loss: 0.6269 Acc: 0.7544\n", "val Loss: 0.3171 Acc: 0.8500\n", "\n", "Epoch 9/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-04.\n", "train Loss: 0.5201 Acc: 0.8095\n", "val Loss: 0.3249 Acc: 0.8900\n", "\n", "Epoch 10/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-04.\n", "train Loss: 0.5775 Acc: 0.7945\n", "val Loss: 0.4130 Acc: 0.8300\n", "\n", "Epoch 11/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-04.\n", "train Loss: 0.4967 Acc: 0.8195\n", "val Loss: 0.3674 Acc: 0.8400\n", "\n", "Epoch 12/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-04.\n", "train Loss: 0.5315 Acc: 0.8095\n", "val Loss: 0.3660 Acc: 0.8700\n", "\n", "Epoch 13/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-04.\n", "train Loss: 0.5024 Acc: 0.8070\n", "val Loss: 0.2591 Acc: 0.9000\n", "\n", "Epoch 14/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-04.\n", "train Loss: 0.4519 Acc: 0.8070\n", "val Loss: 0.3814 Acc: 0.8500\n", "\n", "Epoch 15/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-04.\n", "train Loss: 0.4382 Acc: 0.8396\n", "val Loss: 0.3054 Acc: 0.8600\n", "\n", "Epoch 16/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-04.\n", "train Loss: 0.4600 Acc: 0.8095\n", "val Loss: 0.2740 Acc: 0.8800\n", "\n", "Epoch 17/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-04.\n", "train Loss: 0.4654 Acc: 0.8070\n", "val Loss: 0.3624 Acc: 0.8700\n", "\n", "Epoch 18/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-04.\n", "train Loss: 0.4763 Acc: 0.8421\n", "val Loss: 0.4194 Acc: 0.8500\n", "\n", "Epoch 19/19\n", "----------\n", "Adjusting learning rate of group 0 to 1.0000e-05.\n", "train Loss: 0.4027 Acc: 0.8672\n", "val Loss: 0.3007 Acc: 0.9100\n", "\n", "Training complete in 32m 15s\n", "Best val Acc: 0.910000\n" ] } ], "source": [ "# This is a way to avoid errors for corrupted images\n", "from PIL import ImageFile\n", "\n", "ImageFile.LOAD_TRUNCATED_IMAGES = True\n", "\n", "conv_net = train_model(conv_net, criterion, optimizer, exp_lr_scheduler, num_epochs=20)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 687 }, "id": "u_24WdOKnoHt", "outputId": "dc49ea40-73b4-4a54-ea2c-ca7480efffbd" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light", "tags": [] }, "output_type": "display_data" } ], "source": [ "visualize_predictions(conv_net, 10)\n", "plt.ioff()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "id": "MHGHnb8JLyQF" }, "source": [ "# Exporting to ONNX format and Running the model with ONNX runtime\n", "We are now going to use pytorch exporter to export our model in ONNX format. Then we are going to load our model on the onnx runtime and do inference on some images." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "8g7iKsIoMkWX" }, "outputs": [], "source": [ "# Running inference with a dummy tensor to fix input sizes of the network\n", "x = torch.randn(1, 3, 224, 224, requires_grad=True)\n", "x = x.to(device)\n", "torch_out = conv_net(x)\n", "\n", "# Export the model\n", "torch.onnx.export(\n", " conv_net, # model being run\n", " x, # model input (or a tuple for multiple inputs)\n", " \"Plant_classifier.onnx\", # where to save the model (can be a file or file-like object)\n", " export_params=True, # store the trained parameter weights inside the model file\n", " opset_version=13,\n", ") # the ONNX version to export the model to" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true, "id": "G1DKahk_Oj6y", "jupyter": { "outputs_hidden": true }, "outputId": "6e1711df-6bdd-459a-9a72-011c64ae381b", "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "graph torch-jit-export (\n", " %input.1[FLOAT, 1x3x224x224]\n", ") initializers (\n", " %fc.weight[FLOAT, 4x512]\n", " %fc.bias[FLOAT, 4]\n", " %193[FLOAT, 64x3x7x7]\n", " %194[FLOAT, 64]\n", " %196[FLOAT, 64x64x3x3]\n", " %197[FLOAT, 64]\n", " %199[FLOAT, 64x64x3x3]\n", " %200[FLOAT, 64]\n", " %202[FLOAT, 64x64x3x3]\n", " %203[FLOAT, 64]\n", " %205[FLOAT, 64x64x3x3]\n", " %206[FLOAT, 64]\n", " %208[FLOAT, 128x64x3x3]\n", " %209[FLOAT, 128]\n", " %211[FLOAT, 128x128x3x3]\n", " %212[FLOAT, 128]\n", " %214[FLOAT, 128x64x1x1]\n", " %215[FLOAT, 128]\n", " %217[FLOAT, 128x128x3x3]\n", " %218[FLOAT, 128]\n", " %220[FLOAT, 128x128x3x3]\n", " %221[FLOAT, 128]\n", " %223[FLOAT, 256x128x3x3]\n", " %224[FLOAT, 256]\n", " %226[FLOAT, 256x256x3x3]\n", " %227[FLOAT, 256]\n", " %229[FLOAT, 256x128x1x1]\n", " %230[FLOAT, 256]\n", " %232[FLOAT, 256x256x3x3]\n", " %233[FLOAT, 256]\n", " %235[FLOAT, 256x256x3x3]\n", " %236[FLOAT, 256]\n", " %238[FLOAT, 512x256x3x3]\n", " %239[FLOAT, 512]\n", " %241[FLOAT, 512x512x3x3]\n", " %242[FLOAT, 512]\n", " %244[FLOAT, 512x256x1x1]\n", " %245[FLOAT, 512]\n", " %247[FLOAT, 512x512x3x3]\n", " %248[FLOAT, 512]\n", " %250[FLOAT, 512x512x3x3]\n", " %251[FLOAT, 512]\n", ") {\n", " %192 = Conv[dilations = [1, 1], group = 1, kernel_shape = [7, 7], pads = [3, 3, 3, 3], strides = [2, 2]](%input.1, %193, %194)\n", " %125 = Relu(%192)\n", " %126 = MaxPool[ceil_mode = 0, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [2, 2]](%125)\n", " %195 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%126, %196, %197)\n", " %129 = Relu(%195)\n", " %198 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%129, %199, %200)\n", " %132 = Add(%198, %126)\n", " %133 = Relu(%132)\n", " %201 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%133, %202, %203)\n", " %136 = Relu(%201)\n", " %204 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%136, %205, %206)\n", " %139 = Add(%204, %133)\n", " %140 = Relu(%139)\n", " %207 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [2, 2]](%140, %208, %209)\n", " %143 = Relu(%207)\n", " %210 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%143, %211, %212)\n", " %213 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [2, 2]](%140, %214, %215)\n", " %148 = Add(%210, %213)\n", " %149 = Relu(%148)\n", " %216 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%149, %217, %218)\n", " %152 = Relu(%216)\n", " %219 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%152, %220, %221)\n", " %155 = Add(%219, %149)\n", " %156 = Relu(%155)\n", " %222 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [2, 2]](%156, %223, %224)\n", " %159 = Relu(%222)\n", " %225 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%159, %226, %227)\n", " %228 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [2, 2]](%156, %229, %230)\n", " %164 = Add(%225, %228)\n", " %165 = Relu(%164)\n", " %231 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%165, %232, %233)\n", " %168 = Relu(%231)\n", " %234 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%168, %235, %236)\n", " %171 = Add(%234, %165)\n", " %172 = Relu(%171)\n", " %237 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [2, 2]](%172, %238, %239)\n", " %175 = Relu(%237)\n", " %240 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%175, %241, %242)\n", " %243 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [2, 2]](%172, %244, %245)\n", " %180 = Add(%240, %243)\n", " %181 = Relu(%180)\n", " %246 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%181, %247, %248)\n", " %184 = Relu(%246)\n", " %249 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%184, %250, %251)\n", " %187 = Add(%249, %181)\n", " %188 = Relu(%187)\n", " %189 = GlobalAveragePool(%188)\n", " %190 = Flatten[axis = 1](%189)\n", " %191 = Gemm[alpha = 1, beta = 1, transB = 1](%190, %fc.weight, %fc.bias)\n", " return %191\n", "}\n" ] } ], "source": [ "# load the model with the onnx API \n", "onnx_model = onnx.load(\"Plant_classifier.onnx\")\n", "onnx.checker.check_model(onnx_model)\n", "# Print a human readable representation of the onnx graph\n", "print(onnx.helper.printable_graph(onnx_model.graph))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Fy42HOrFjrOu", "outputId": "ed0889e7-8397-4f0c-ce23-2d03a568301f" }, "outputs": [ { "data": { "text/plain": [ "tensor([[[[0.5255, 0.5216, 0.5216, ..., 0.8314, 0.8275, 0.7961],\n", " [0.5020, 0.5216, 0.5529, ..., 0.8353, 0.8431, 0.8392],\n", " [0.4980, 0.5490, 0.5922, ..., 0.7882, 0.8157, 0.8353],\n", " ...,\n", " [0.6588, 0.6627, 0.6471, ..., 0.7529, 0.7490, 0.7961],\n", " [0.6745, 0.6784, 0.6627, ..., 0.7843, 0.7843, 0.8196],\n", " [0.6784, 0.6824, 0.6745, ..., 0.7961, 0.7882, 0.8118]],\n", "\n", " [[0.4824, 0.4902, 0.4902, ..., 0.7765, 0.7686, 0.7412],\n", " [0.4706, 0.4902, 0.5137, ..., 0.7804, 0.7882, 0.7765],\n", " [0.4706, 0.5098, 0.5569, ..., 0.7373, 0.7569, 0.7686],\n", " ...,\n", " [0.6235, 0.6275, 0.6157, ..., 0.7098, 0.6980, 0.7333],\n", " [0.6314, 0.6314, 0.6235, ..., 0.7333, 0.7255, 0.7569],\n", " [0.6353, 0.6314, 0.6275, ..., 0.7451, 0.7373, 0.7569]],\n", "\n", " [[0.4157, 0.4275, 0.4196, ..., 0.6824, 0.6745, 0.6549],\n", " [0.3922, 0.4078, 0.4275, ..., 0.6824, 0.6941, 0.6863],\n", " [0.3804, 0.4196, 0.4627, ..., 0.6549, 0.6784, 0.6902],\n", " ...,\n", " [0.5686, 0.5725, 0.5569, ..., 0.6353, 0.6275, 0.6667],\n", " [0.5725, 0.5725, 0.5569, ..., 0.6627, 0.6588, 0.6941],\n", " [0.5765, 0.5725, 0.5686, ..., 0.6745, 0.6627, 0.6941]]]])" ] }, "execution_count": 43, "metadata": { "tags": [] }, "output_type": "execute_result" } ], "source": [ "# Pre-processing an image to feed it as input in the model.\n", "# Point the Path to one of the images in your system\n", "IMAGE_PATH = \"/home/air/Desktop/EDEN-REPO/eden_library_notebooks/eden-library-datasets/pytorch-onnx/val/Cotton-100619-Healthy-zz-V1-20210225102300/DSC_0653.JPG\"\n", "img = Image.open(\n", " IMAGE_PATH\n", ") # Define an image path for inference.\n", "resize = transforms.Resize([224, 224])\n", "img = resize(img)\n", "to_tensor = transforms.ToTensor()\n", "img = to_tensor(img)\n", "img.unsqueeze_(0)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "wTj6tn-7OsWD", "outputId": "4460b7f0-8bac-42ad-c7ce-fcb03b080d17" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Black nightsade-220519-Weed-zz-V1-20210225102034', 'Cotton-100619-Healthy-zz-V1-20210225102300', 'Tomato-240519-Healthy-zz-V1-20210225103740', 'Velvet leaf-220519-Weed-zz-V1-20210225104123']\n", "[array([[ 1.3752831, 1.7617769, -2.3463416, -1.4205171]], dtype=float32)] \n", "\n", "Model's prediction : Cotton-100619-Healthy-zz-V1-20210225102300\n" ] } ], "source": [ "# Executing inference on the model\n", "sess = onnxruntime.InferenceSession(\"Plant_classifier.onnx\")\n", "\n", "\n", "def to_numpy(tensor):\n", " return (\n", " tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()\n", " )\n", "\n", "\n", "# compute ONNX Runtime output prediction\n", "sess_inputs = {sess.get_inputs()[0].name: to_numpy(img)}\n", "sess_outs = sess.run(None, sess_inputs)\n", "\n", "\n", "final_pred = np.argmax(np.array(sess_outs))\n", "print(class_names)\n", "print(sess_outs, \"\\n\")\n", "print(\"Model's prediction : {}\".format(class_names[final_pred]))" ] }, { "cell_type": "markdown", "metadata": { "id": "dqhVkpKHbfCy" }, "source": [ "## Possible Extensions\n", "1. Use a different pre-trained network (for instance, InceptionNet).\n", "2. Try a different training approach where pre-trained weights are not loaded.\n", "3. Deploy the ONNX model somewhere else eg. cloud, edge device.\n", "3. Try different epochs and batch sizes.\n", "4. Try different augmentation techniques." ] }, { "cell_type": "markdown", "metadata": { "id": "Nz7IYxN9Tlmo" }, "source": [ "## Bibliography\n", "\n", "Too, E.C., Yujian, L., Njuki, S., & Ying-chun, L. (2019). A comparative study of fine-tuning deep learning models for plant disease identification. Comput. Electron. Agric., 161, 272-279.\n", "\n", "Suh, H.K., IJsselmuiden, J., Hofstee, J.W., van Henten, E.J., (2018). Transfer learning for the classification of sugar beet and volunteer potato under field conditions. Biosystems Engineering; 174:50–65.\n", "\n", "Espejo-Garcia, B., Mylonas, N., Athanasakos, L., & Fountas, S., (2020). Improving\n", "Weeds Identification with a Repository of Agricultural Pre-trained Deep Neural\n", "Networks. Computers and Electronics in Agriculture; 175 (August).\n", "\n", "https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html\n", "\n", "https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html\n", "\n", "https://cloudblogs.microsoft.com/opensource/2019/05/22/onnx-runtime-machine-learning-inferencing-0-4-release/\n", "\n", "https://github.com/onnx/onnx\n", "\n", "https://www.oreilly.com/library/view/programming-pytorch-for/9781492045342/ch04.html" ] } ], "metadata": { "accelerator": "GPU", "colab": { "collapsed_sections": [], "name": "Copy of weeds_identification-transfer_learning-7.ipynb", "provenance": [] }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.16" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "2ea2870da6584c60bc33c66bd5077719": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "initial" } }, "516ed6a3704249d580b9ff66f442d834": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_ef6fe6f2b0534b9a8099562868e71f87", "placeholder": "​", "style": "IPY_MODEL_5fa532133b1e4b4e9656c83ab4b00d2d", "value": " 44.7M/44.7M [44:34<00:00, 17.5kB/s]" } }, "597e590352c143f7bd3d45a30d72ea88": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "5fa532133b1e4b4e9656c83ab4b00d2d": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "8058e4f2252f43b3bfc80a843d617905": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_a6390e52137a49ee9d981268a9cb3d68", "IPY_MODEL_516ed6a3704249d580b9ff66f442d834" ], "layout": "IPY_MODEL_597e590352c143f7bd3d45a30d72ea88" } }, "a6390e52137a49ee9d981268a9cb3d68": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "100%", "description_tooltip": null, "layout": "IPY_MODEL_b190165fbff149b69b490ca8ffa437b9", "max": 46830571, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_2ea2870da6584c60bc33c66bd5077719", "value": 46830571 } }, "b190165fbff149b69b490ca8ffa437b9": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "ef6fe6f2b0534b9a8099562868e71f87": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } } } } }, "nbformat": 4, "nbformat_minor": 1 }