public_marcs_CNN_RESNET50.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyN/h/9euMEXI0aX9bpydPDW",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/marcivanmanalac/CRB_CNN/blob/main/public_marcs_CNN_RESNET50.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Import Google Drive.\n"
      ],
      "metadata": {
        "id": "1mvBXA49jGis"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9KRGxx8wi520"
      },
      "outputs": [],
      "source": [
        "#@markdown Import Drive at the start of runtime. Ensure your images and labels are on your drive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "#Check Dataset\n",
        "!ls -l /content/drive/MyDrive/"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Run this Cell to update XML Paths for new labeled images\n"
      ],
      "metadata": {
        "id": "wovK2somKp7L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown This code block defines a function batch_edit_xml() that takes in two arguments xml_directory and jpg_directory. The function searches through all the XML files in xml_directory, finds the corresponding JPG file in jpg_directory, updates the path element in the XML file with the JPG file's path, and writes the changes back to the XML file. The function then prints the current count and the total number of files processed. The main() function calls batch_edit_xml() three times with different xml_directory and jpg_directory arguments to edit multiple sets of XML files.\n",
        "\n",
        "import os\n",
        "from xml.etree import ElementTree as ET\n",
        "\n",
        "def batch_edit_xml(xml_directory, jpg_directory):\n",
        "    count = 1 # initializing count to 1\n",
        "    for root, dirs, files in os.walk(xml_directory):\n",
        "        for file in files:\n",
        "            if file.endswith(\".xml\"):\n",
        "                file_path = os.path.join(root, file) # creating a file path by joining the root and the file name\n",
        "                xml_tree = ET.parse(file_path) # parsing the XML file\n",
        "                xml_root = xml_tree.getroot() # getting the root of the XML file\n",
        "                filename = os.path.splitext(file)[0] # getting the file name without the extension\n",
        "                jpg_path = os.path.join(jpg_directory, os.path.basename(root), filename + '.jpg').replace(os.sep, '/') # creating a jpg path and converting to forward slashes\n",
        "                xml_root.find('./path').text = jpg_path # finding the path element in the XML file and updating it with the jpg_path\n",
        "                xml_tree.write(file_path) # writing the changes back to the XML file\n",
        "                print(f\"{count} of {len(files)}: {file_path}\") # printing the current count and the total number of files processed\n",
        "                count += 1\n",
        "                if count > len(files): # checking if the count has reached the length of the files\n",
        "                    count = 1 # resetting the count back to 1\n",
        "    print(\"Edit Complete\") # indicating that the edit is complete\n",
        "\n",
        "\n",
        "#@markdown Input your image-label directory pairs\n",
        "def main():\n",
        "    dir1_xml_dir = '/content/drive/MyDrive/PATH/TO/XML_DIR/' #@param {type:\"string\"}\n",
        "    dir1_jpg_dir = '/content/drive/MyDrive/PATH/TO/JPG_DIR/'#@param {type:\"string\"}\n",
        "    dir2_xml_dir = '/content/drive/MyDrive/PATH/TO/XML_DIR/'#@param {type:\"string\"}\n",
        "    dir2_jpg_dir = '/content/drive/MyDrive/PATH/TO/JPG_DIR/'#@param {type:\"string\"}\n",
        "    dir3_xml_dir = '/content/drive/MyDrive/PATH/TO/XML_DIR'#@param {type:\"string\"}\n",
        "    dir3_jpg_dir = '/content/drive/MyDrive/PATH/TO/JPG_DIR/'#@param {type:\"string\"}\n",
        "    batch_edit_xml(dir1_xml_dir1,dir1_jpg_dir)\n",
        "    batch_edit_xml(dir2_xml_dir,dir2_jpg_dir)\n",
        "    batch_edit_xml(dir3_xml_dir,dir3_jpg_dir)\n",
        "\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()\n",
        "\n"
      ],
      "metadata": {
        "id": "yCf8oTpXLA6Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Create the Annotations CSV"
      ],
      "metadata": {
        "id": "U7y2IZ9xTxfb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import argparse\n",
        "import csv\n",
        "import os\n",
        "import tkinter as tk\n",
        "from tkinter import filedialog\n",
        "import xml.etree.ElementTree as ET\n",
        "\n",
        "\n",
        "#@markdown The get_dirs function prompts the user for the input directory of the XML files and the output directory of the resulting CSV file, as well as the class names and labels for the objects in the images.\n",
        "def get_dirs():\n",
        "    # Define XML Root Directory and CSV Output Directory.\n",
        "    #@markdown Input Path to XML Directory.\n",
        "    xml_dir = '/content/drive/MyDrive/labeled_images_dataset/' #@param {type:\"string\"}\n",
        "    #@markdown Input Path to Destination Directory.\n",
        "    csv_dir = '/content/drive/MyDrive/labeled_images_dataset/' #@param {type:\"string\"}\n",
        "    #@markdown Input the class names separated by a comma (NO SPACES).\n",
        "    class_names = input(\"Enter class names separated by commas: \").split(\",\") #@param {type:\"string\"}\n",
        "    labels = class_names\n",
        "    return xml_dir, csv_dir, class_names, labels\n",
        "\n",
        "#@markdown The process_xml_file function processes a single XML file, extracting the bounding box coordinates and label for each object annotation that matches the specified class names. The resulting data is returned as a list.\n",
        "def process_xml_file(xml_file, class_names, labels):\n",
        "    tree = ET.parse(xml_file)\n",
        "    root = tree.getroot()\n",
        "    data = []\n",
        "    for obj in root.findall(\"object\"):\n",
        "        name = obj.find(\"name\").text\n",
        "        if name in class_names:\n",
        "            label = labels[class_names.index(name)].strip() # strip spaces from the label value\n",
        "            bndbox = obj.find(\"bndbox\")\n",
        "            xmin = int(bndbox.find(\"xmin\").text)\n",
        "            ymin = int(bndbox.find(\"ymin\").text)\n",
        "            xmax = int(bndbox.find(\"xmax\").text)\n",
        "            ymax = int(bndbox.find(\"ymax\").text)\n",
        "            path = root.find(\"path\").text  # get the path tag\n",
        "            #trying to fix CSV output\n",
        "            #data.append((path, xmin, ymin, xmax, ymax, label))\n",
        "            data.append((path, xmin, ymin, xmax, ymax, label))\n",
        "\n",
        "    return data\n",
        "\n",
        "#@markdown The process_xml_files function iterates through all XML files in the specified input directory and processes them using the process_xml_file function. The resulting data is written to a CSV file with the filename, path, bounding box coordinates, and label for each object annotation.\n",
        "def process_xml_files(xml_dir, csv_dir, class_names, labels):\n",
        "    csv_file = os.path.join(csv_dir, \"annotations.csv\")\n",
        "    with open(csv_file, \"w\") as f:\n",
        "        writer = csv.writer(f)\n",
        "        writer.writerow([\"filename\", \"path\", \"xmin\", \"ymin\", \"xmax\", \"ymax\", \"label\"])  # add \"path\" column\n",
        "        for root, dirs, files in os.walk(xml_dir):\n",
        "            for file in files:\n",
        "                if file.endswith(\".xml\"):\n",
        "                    xml_file = os.path.join(root, file)\n",
        "                    data = process_xml_file(xml_file, class_names, labels)\n",
        "                    if data:\n",
        "                        filename = os.path.splitext(file)[0] + \".jpg\"\n",
        "                        for row in data:\n",
        "                            #EDIT\n",
        "                            #writer.writerow(list(row))  # include path value as first element\n",
        "                            writer.writerow([filename] + list(row))\n",
        "#@markdown The main method calls the get_dirs and process_xml_files functions and prints the output CSV file path to the console.                            \n",
        "def main():\n",
        "    xml_dir, csv_dir, class_names, labels = get_dirs()\n",
        "    process_xml_files(xml_dir, csv_dir, class_names, labels)\n",
        "    print(\"CSV file saved to: \", os.path.join(csv_dir, \"annotations.csv\"))\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()\n"
      ],
      "metadata": {
        "id": "V3TxyuWuT1bB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Check the created CSV file"
      ],
      "metadata": {
        "id": "2lUsjASY1XRk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown This imports the pandas library and uses it to read in a CSV file from a specified path. It then counts the number of rows in the file and prints the count along with the first three rows of data in the file.\n",
        "import pandas as pd\n",
        "# Replace with the path to your CSV file\n",
        "#@markdown Input Path to the annotations CSV\n",
        "csv_path = \"/PATH/TO/annotations.csv\" #@param {type:\"string\"} \n",
        "df = pd.read_csv(csv_path)\n",
        "# Count the number of rows not including the header\n",
        "num_rows = df.shape[0] - 1\n",
        "\n",
        "# Print the number of rows\n",
        "print(\"Lable Count: \", num_rows)\n",
        "print(df.head(3))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ViQhJjGF1qpT",
        "outputId": "10fbc6f3-1dc5-4f56-ddc6-eb14d59b5b2c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Lable Count:  13529\n",
            "  filename                                               path  xmin  ymin  \\\n",
            "0   32.jpg  /content/drive/MyDrive/labeled_images_dataset/...   605   134   \n",
            "1   32.jpg  /content/drive/MyDrive/labeled_images_dataset/...   528    90   \n",
            "2   32.jpg  /content/drive/MyDrive/labeled_images_dataset/...   511    66   \n",
            "\n",
            "   xmax  ymax           label  \n",
            "0   635   165           notch  \n",
            "1   596   129           notch  \n",
            "2   651   193  infested_frond  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Randomly Split the Annotations CSV to create training, validation, & test CSV files\n",
        "\n"
      ],
      "metadata": {
        "id": "hNGpo_t4pKon"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown This imports necessary modules and defines file paths. It reads a CSV file, shuffles the rows randomly, and splits the data into training, validation, and testing sets according to specified proportions. It then writes the rows to separate CSV files for each split and removes blank rows from each file. Finally, it prints a message indicating the code has finished.\n",
        "import csv\n",
        "import random\n",
        "import os\n",
        "\n",
        "# Enter input CSV File Path and Destination\n",
        "#@markdown Input Path to XML Directory.\n",
        "input_file_path = 'PATH/TO/annotations.csv' #@param {type:\"string\"} \n",
        "output_dir_path = 'PATH/TO/DST_DIRECTORY' #@param {type:\"string\"} \n",
        "\n",
        "# Path to the output CSV files for the training, validation, and testing sets\n",
        "train_csv_file = os.path.join(output_dir_path, 'train.csv')\n",
        "val_csv_file = os.path.join(output_dir_path, 'val.csv')\n",
        "test_csv_file = os.path.join(output_dir_path, 'test.csv')\n",
        "\n",
        "# Proportions of the split (train: 60%, val: 30%, test: 10%)\n",
        "train_split = 0.6\n",
        "val_split = 0.3\n",
        "test_split = 0.1\n",
        "\n",
        "# Read the CSV file and split the rows randomly\n",
        "with open(input_file_path, 'r') as f:\n",
        "    reader = csv.reader(f)\n",
        "    header = next(reader, None)  # Skip the header row\n",
        "\n",
        "    # Shuffle the rows randomly\n",
        "    rows = list(reader)\n",
        "    random.shuffle(rows)\n",
        "\n",
        "    # Compute the number of rows for each split\n",
        "    num_rows = len(rows)\n",
        "    num_train = int(num_rows * train_split)\n",
        "    num_val = int(num_rows * val_split)\n",
        "    num_test = num_rows - num_train - num_val\n",
        "\n",
        "    # Write the rows to the output CSV files\n",
        "    with open(train_csv_file, 'w', newline='') as train_f, \\\n",
        "            open(val_csv_file, 'w', newline='') as val_f, \\\n",
        "            open(test_csv_file, 'w', newline='') as test_f:\n",
        "        train_writer = csv.writer(train_f)\n",
        "        val_writer = csv.writer(val_f)\n",
        "        test_writer = csv.writer(test_f)\n",
        "\n",
        "        # Write the rows to the output CSV files\n",
        "        for i, row in enumerate(rows):\n",
        "            if i < num_train:\n",
        "                train_writer.writerow(row)\n",
        "            elif i < num_train + num_val:\n",
        "                val_writer.writerow(row)\n",
        "            else:\n",
        "                test_writer.writerow(row)\n",
        "                \n",
        "# Remove blank rows from the output CSV files\n",
        "for file_path in [train_csv_file, val_csv_file, test_csv_file]:\n",
        "    with open(file_path, 'r') as f:\n",
        "        rows = list(csv.reader(f))\n",
        "    \n",
        "    with open(file_path, 'w', newline='') as f:\n",
        "        writer = csv.writer(f)\n",
        "        writer.writerow(header)\n",
        "        for row in rows:\n",
        "            if any(row):\n",
        "                writer.writerow(row)\n",
        "                \n",
        "print(\"Finished!\")\n"
      ],
      "metadata": {
        "id": "7QJTZaXapIaH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Check new train, val, and test CSV Files\n",
        "\n",
        " *** START HERE IF DATA IS READY ***"
      ],
      "metadata": {
        "id": "98IgemB03okj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import csv\n",
        "import os\n",
        "import pandas as pd\n",
        "#@markdown Replace with the path to your CSV file\n",
        "csv_train_path = \"PATH/TO/train.csv\"   #@param {type:\"string\"} \n",
        "csv_val_path = \"PATH/TO/val.csv\"   #@param {type:\"string\"} \n",
        "csv_test_path = \"PATH/TO/test.csv\"  #@param {type:\"string\"} \n",
        "\n",
        "#Load Data Frame\n",
        "df_train = pd.read_csv(csv_train_path)\n",
        "df_val = pd.read_csv(csv_val_path)\n",
        "df_test = pd.read_csv(csv_test_path)\n",
        "\n",
        "#Print first three values\n",
        "print(df_train.head(3))\n",
        "print(df_val.head(3))\n",
        "print(df_test.head(3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zJtE6nGy3qfn",
        "outputId": "bd098f68-c87a-4273-802d-e2990e333cc1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  filename                                               path  xmin  ymin  \\\n",
            "0   11.jpg  /content/drive/MyDrive/labeled_images_dataset/...   740   520   \n",
            "1   31.jpg  /content/drive/MyDrive/labeled_images_dataset/...   533   420   \n",
            "2   33.jpg  /content/drive/MyDrive/labeled_images_dataset/...   126   369   \n",
            "\n",
            "   xmax  ymax           label  \n",
            "0   783   545           notch  \n",
            "1   578   488   healthy_frond  \n",
            "2   360   534  infested_frond  \n",
            "  filename                                               path  xmin  ymin  \\\n",
            "0   35.jpg  /content/drive/MyDrive/labeled_images_dataset/...   348   591   \n",
            "1   31.jpg  /content/drive/MyDrive/labeled_images_dataset/...   843   835   \n",
            "2   24.jpg  /content/drive/MyDrive/labeled_images_dataset/...   750   104   \n",
            "\n",
            "   xmax  ymax          label  \n",
            "0   400   628          notch  \n",
            "1  1000  1000  infested_tree  \n",
            "2  1000   709   healthy_tree  \n",
            "  filename                                               path  xmin  ymin  \\\n",
            "0   21.jpg  /content/drive/MyDrive/labeled_images_dataset/...   380     1   \n",
            "1   12.jpg  /content/drive/MyDrive/labeled_images_dataset/...   938    41   \n",
            "2   24.jpg  /content/drive/MyDrive/labeled_images_dataset/...    72   644   \n",
            "\n",
            "   xmax  ymax          label  \n",
            "0   809   217  infested_tree  \n",
            "1   973    79          notch  \n",
            "2   183   799  healthy_frond  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define:\n",
        "\n",
        "\n",
        "* Preprocessing\n",
        "* Data Augmentation\n",
        "* Batch Size\n",
        "* Image Size\n",
        "* Generators\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "36rl0zx_BSTf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown This code block is importing necessary libraries and defining data generators for image preprocessing, \n",
        "#@markdown data augmentation, and data splitting. It also loads CSV files and defines data generators for training, validation, \n",
        "#@markdown and testing. The batch size and image size are also defined. The code then catches any warnings and extracts invalid \n",
        "#@markdown image filenames for each of the data generators. \n",
        "\n",
        "import tensorflow as tf\n",
        "import keras\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "import pandas as pd\n",
        "import warnings\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Define image preprocessing and data augmentation\n",
        "train_datagen = ImageDataGenerator(rescale=1./255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True)\n",
        "val_datagen = ImageDataGenerator(rescale=1./255)\n",
        "test_datagen = ImageDataGenerator(rescale=1./255)\n",
        "\n",
        "# Define batch size and image size\n",
        "batch_size = 32 #@param {type:\"string\"} \n",
        "img_size = (224, 224) #@param {type:\"string\"} \n",
        "\n",
        "# Load dataframes\n",
        "df_train = pd.read_csv(csv_train_path)\n",
        "df_val = pd.read_csv(csv_val_path)\n",
        "df_test = pd.read_csv(csv_test_path)\n",
        "\n",
        "# Define data generators for training, validation, and testing\n",
        "train_generator = train_datagen.flow_from_dataframe(\n",
        "    dataframe=df_train,\n",
        "    x_col='path',\n",
        "    y_col='label',\n",
        "    target_size=img_size,\n",
        "    batch_size=batch_size,\n",
        "    class_mode='categorical',\n",
        "    shuffle=True\n",
        ")\n",
        "\n",
        "val_generator = val_datagen.flow_from_dataframe(\n",
        "    dataframe=df_val,\n",
        "    x_col='path',\n",
        "    y_col='label',\n",
        "    target_size=img_size,\n",
        "    batch_size=batch_size,\n",
        "    class_mode='categorical',\n",
        "    shuffle=False\n",
        ")\n",
        "\n",
        "test_generator = test_datagen.flow_from_dataframe(\n",
        "    dataframe=df_test,\n",
        "    x_col='path',\n",
        "    y_col='label',\n",
        "    target_size=img_size,\n",
        "    batch_size=batch_size,\n",
        "    class_mode='categorical',\n",
        "    shuffle=False\n",
        ")\n",
        "\n",
        "# Retrieve a batch of images and labels from the training generator\n",
        "x_batch, y_batch = next(train_generator)\n",
        "\n",
        "# Print the shape of the batch\n",
        "print(\"Train generator batch shape:\", x_batch.shape, y_batch.shape)\n",
        "\n",
        "# Display the first couple of images\n",
        "fig, axes = plt.subplots(nrows=1, ncols=4, figsize=(20, 20))\n",
        "axes[0].imshow(x_batch[0])\n",
        "axes[1].imshow(x_batch[1])\n",
        "axes[2].imshow(x_batch[2])\n",
        "axes[3].imshow(x_batch[3])\n",
        "plt.show()\n",
        "\n",
        "# Retrieve a batch of images and labels from the validation generator\n",
        "x_batch, y_batch = next(val_generator)\n",
        "\n",
        "# Print the shape of the batch\n",
        "print(\"Validation generator batch shape:\", x_batch.shape, y_batch.shape)\n",
        "\n",
        "# Display the first couple of images\n",
        "fig, axes = plt.subplots(nrows=1, ncols=4, figsize=(20, 20))\n",
        "axes[0].imshow(x_batch[0])\n",
        "axes[1].imshow(x_batch[1])\n",
        "axes[2].imshow(x_batch[2])\n",
        "axes[3].imshow(x_batch[3])\n",
        "plt.show()\n",
        "\n",
        "# Retrieve a batch of images and labels from the test generator\n",
        "x_batch, y_batch = next(test_generator)\n",
        "\n",
        "# Print the shape of the batch\n",
        "print(\"Test generator batch shape:\", x_batch.shape, y_batch.shape)\n",
        "\n",
        "# Display the first couple of images\n",
        "fig, axes = plt.subplots(nrows=1, ncols=4, figsize=(20, 20))\n",
        "axes[0].imshow(x_batch[0])\n",
        "axes[1].imshow(x_batch[1])\n",
        "axes[2].imshow(x_batch[2])\n",
        "axes[3].imshow(x_batch[3])\n",
        "plt.show()\n",
        "\n",
        "# Catch warning and extract invalid image filenames for train_generator\n",
        "invalid_paths_train = []\n",
        "with warnings.catch_warnings(record=True) as w:\n",
        "    train_generator.next()\n",
        "    for warning in w:\n",
        "        if 'invalid image filename(s)' in str(warning.message):\n",
        "            invalid_paths_train.extend(str(warning.message).split(' ')[-1].split(';')[:-1])\n",
        "print('Invalid image paths for training generator:', invalid_paths_train)\n",
        "\n",
        "# Catch warning and extract invalid image filenames for val_generator\n",
        "invalid_paths_val = []\n",
        "with warnings.catch_warnings(record=True) as w:\n",
        "    val_generator.next()\n",
        "    for warning in w:\n",
        "        if 'invalid image filename(s)' in str(warning.message):\n",
        "            invalid_paths_val.extend(str(warning.message).split(' ')[-1].split(';')[:-1])\n",
        "print('Invalid image paths for validation generator:', invalid_paths_val)\n",
        "\n",
        "# Catch warning and extract invalid image filenames for test_generator\n",
        "invalid_paths_test = []\n",
        "with warnings.catch_warnings(record=True) as w:\n",
        "    test_generator.next()\n",
        "    for warning in w:\n",
        "        if 'invalid image filename(s)' in str(warning.message):\n",
        "            invalid_paths_test.extend(str(warning.message).split(' ')[-1].split(';')[:-1])\n",
        "print('Invalid image paths for test generator:', invalid_paths_test)\n",
        "\n"
      ],
      "metadata": {
        "id": "5-7p0leQmqf1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define and Compile the model"
      ],
      "metadata": {
        "id": "ITPIAJDLHlMQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown This code block asks the user whether they are using a TPU or GPU and sets up the appropriate strategy. \n",
        "#@markdown If the user selects TPU, the code connects to the TPU, initializes the TPU system, and creates a TPUStrategy object. \n",
        "#@markdown If the user selects GPU, the code creates a MirroredStrategy object. Finally, the code defines and compiles a sequential\n",
        "#@markdown model with a ResNet50 base, global average pooling layer, and softmax output layer, and specifies the loss function, \n",
        "#@markdown optimizer, and metrics to be used in training the model. All of this is done within the scope of the selected strategy.\n",
        "\n",
        "import os\n",
        "import tensorflow as tf\n",
        "\n",
        "# Ask user whether to use TPU or GPU\n",
        "accelerator = \"Are you using a TPU or GPU runtime? Enter 'TPU' or 'GPU': \" #@param{type:\"string\"}\n",
        "\n",
        "if accelerator == 'TPU':\n",
        "  # TPU address\n",
        "  tpu_address = 'grpc://' + os.environ['COLAB_TPU_ADDR']\n",
        "\n",
        "  # Set the TPU address in the environment variable\n",
        "  os.environ['TPU_NAME'] = tpu_address\n",
        "\n",
        "  # Create a TPUClusterResolver object from the address\n",
        "  resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu=tpu_address)\n",
        "\n",
        "  # Connect to the TPU\n",
        "  tf.config.experimental_connect_to_cluster(resolver)\n",
        "\n",
        "  # Initialize the TPU system\n",
        "  tf.tpu.experimental.initialize_tpu_system(resolver)\n",
        "\n",
        "  # Create the strategy using the resolver\n",
        "  strategy = tf.distribute.TPUStrategy(resolver)\n",
        "elif accelerator == 'GPU':\n",
        "  # Create a MirroredStrategy for using the GPU\n",
        "  strategy = tf.distribute.MirroredStrategy()\n",
        "else:\n",
        "  raise ValueError(\"Invalid accelerator. Must be 'TPU' or 'GPU'.\")\n",
        "\n",
        "# Define and compile the model within the strategy scope\n",
        "with strategy.scope():\n",
        "\n",
        "  # Load the ResNet50 model without the top layers\n",
        "  base_model = tf.keras.applications.ResNet50(\n",
        "      include_top=False, weights='imagenet', input_shape=(224, 224, 3)\n",
        "  )\n",
        "\n",
        "  # Freeze the first N layers of the base model layers\n",
        "  N_layers = 10 #layers to be frozen \n",
        "  for layer in base_model.layers[:N_layers]:\n",
        "      layer.trainable = False\n",
        "\n",
        "  # Instantiate Sequential Model\n",
        "  model = tf.keras.models.Sequential([\n",
        "      # Load Base Model and following layers\n",
        "      base_model,\n",
        "      tf.keras.layers.GlobalAveragePooling2D(),\n",
        "      tf.keras.layers.Dense(5, activation='softmax')\n",
        "  ])\n",
        "  model.compile(\n",
        "      loss='categorical_crossentropy',\n",
        "      optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),\n",
        "      metrics=['accuracy']\n",
        "  )\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oONZGAFbHm8U",
        "outputId": "c2d694ef-acfa-434b-8a8f-e001355c4aad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Are you using a TPU or GPU runtime? Enter 'TPU' or 'GPU': GPU\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/resnet/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
            "94765736/94765736 [==============================] - 4s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Training steps"
      ],
      "metadata": {
        "id": "gjLOhponH0NF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown This code block defines the number of training and validation steps per epoch based on the number of \n",
        "#@markdown samples in the training and validation data and the batch size. \n",
        "#@markdown It also sets the number of epochs for training to 10.\n",
        "\n",
        "# Define the number of training and validation steps per epoch\n",
        "train_steps_per_epoch = train_generator.n // batch_size\n",
        "val_steps_per_epoch = val_generator.n // batch_size\n",
        "\n",
        "# Define the number of epochs for training\n",
        "epochs = 10 #@param"
      ],
      "metadata": {
        "id": "9lzKbYI3H2U0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Data Augmentation"
      ],
      "metadata": {
        "id": "K5lBvN1oIByP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown This code block defines data augmentation for training data using the flow_from_dataframe() function from \n",
        "#@markdown Keras. The function takes in the training data as a dataframe, specifies the input and output columns, target image \n",
        "#@markdown size, batch size, and various data augmentation techniques such as horizontal flipping, rotation, shifting,\n",
        "#@markdown shearing, and zooming. The resulting generator will be used for training the CNN model.\n",
        "\n",
        "# Define data augmentation for training data\n",
        "train_augmented_generator = train_datagen.flow_from_dataframe(\n",
        "    dataframe=df_train,\n",
        "    x_col='path',\n",
        "    y_col='label',\n",
        "    target_size=img_size,\n",
        "    batch_size=batch_size,\n",
        "    class_mode='categorical',\n",
        "    shuffle=True,\n",
        "    horizontal_flip=True,\n",
        "    rotation_range=20,\n",
        "    width_shift_range=0.2,\n",
        "    height_shift_range=0.2,\n",
        "    shear_range=0.2,\n",
        "    zoom_range=0.2\n",
        ")\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "__5dH46WIDGl",
        "outputId": "33e358bd-e4a9-454f-fe28-f3bf79078729"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 6563 validated image filenames belonging to 5 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Fit model with augmentation**"
      ],
      "metadata": {
        "id": "Q2yXeuLOIOOf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown This code block trains the model using data augmentation with a specified number of epochs.  \n",
        "#@markdown the model using the fit method, with the training data generator, validation data generator, and number \n",
        "#@markdown of steps per epoch specified. The training history is \n",
        "#@markdown stored in the history variable.\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "from keras.callbacks import EarlyStopping, ModelCheckpoint\n",
        "\n",
        "#clear previous def vairables and reset tf session\n",
        "#tf.keras.backend.clear_session()\n",
        "\n",
        "# Define callbacks\n",
        "callbacks = [\n",
        "    EarlyStopping(monitor='val_loss', patience=3, verbose=1),\n",
        "    ModelCheckpoint(filepath='/content/drive/MyDrive/labeled_images_dataset/model_checkpoint.h5', monitor='val_loss', save_best_only=True, verbose=1)\n",
        "]\n",
        "\n",
        "# Fit the model with data augmentation\n",
        "history = model.fit(\n",
        "    train_augmented_generator,\n",
        "    steps_per_epoch=train_steps_per_epoch,\n",
        "    epochs=epochs,\n",
        "    callbacks=callbacks,\n",
        "    validation_data=val_generator,\n",
        "    validation_steps=val_steps_per_epoch,\n",
        "    verbose=1\n",
        "    )\n",
        "\n",
        "\n",
        "# Create subplots with 1 row and 2 columns\n",
        "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n",
        "\n",
        "# Plot training loss\n",
        "axs[0].plot(history.history['loss'])\n",
        "axs[0].plot(history.history['val_loss'])\n",
        "axs[0].set_title('Model Loss')\n",
        "axs[0].set_ylabel('Loss')\n",
        "axs[0].set_xlabel('Epoch')\n",
        "axs[0].legend(['Train', 'Validation'], loc='upper left')\n",
        "\n",
        "# Plot training accuracy\n",
        "axs[1].plot(history.history['accuracy'])\n",
        "axs[1].plot(history.history['val_accuracy'])\n",
        "axs[1].set_title('Model Accuracy')\n",
        "axs[1].set_ylabel('Accuracy')\n",
        "axs[1].set_xlabel('Epoch')\n",
        "axs[1].legend(['Train', 'Validation'], loc='upper left')\n",
        "\n",
        "# Show the plots\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yaoj0FIHIP1_",
        "outputId": "5863c0bb-51bc-4982-d8c8-800d5050263e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Training: 100%|██████████| 10/10 [1:00:29<00:00, 362.95s/it]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Save The model"
      ],
      "metadata": {
        "id": "y8iyKDJ6a6nu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Save the model architecture and weights\n",
        "model_name = 'Enter Model name here ending with .h5' #@param{type:'string'}\n",
        "model.save(model_name)"
      ],
      "metadata": {
        "id": "sV1feK0na7sq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Save the model architecture and weights to a specific path\n",
        "model_full_path_name = 'Enter Model name here ending with .h5' #@param{type:'string'}\n",
        "model.save(f'/content/drive/MyDrive/{model_full_path_name}')"
      ],
      "metadata": {
        "id": "RHNRKjhLoV3D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**START HERE IF LOADING A MODEL**"
      ],
      "metadata": {
        "id": "DNOxfN8yykq8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#load drive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "id": "TR-pH6450Ue0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "import keras\n",
        "from keras.models import load_model\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "import csv\n",
        "import os\n",
        "import pandas as pd\n",
        "\n",
        " # Replace with the path to your CSV file\n",
        "csv_test_path = \"/content/drive/MyDrive/labeled_images_dataset/test.csv\" \n",
        "\n",
        "# Define batch size and image size\n",
        "batch_size = 32\n",
        "img_size = (224, 224)\n",
        "\n",
        "#Load Data Frame\n",
        "df_test = pd.read_csv(csv_test_path)\n",
        "\n",
        "# Define image preprocessing and data augmentation\n",
        "test_datagen = ImageDataGenerator(rescale=1./255)\n",
        "\n",
        "test_generator = test_datagen.flow_from_dataframe(\n",
        "    dataframe=df_test,\n",
        "    x_col='path',\n",
        "    y_col='label',\n",
        "    target_size=img_size,\n",
        "    batch_size=batch_size,\n",
        "    class_mode='categorical',\n",
        "    shuffle=False\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1sBdhuOlynbw",
        "outputId": "301f8ad8-3202-4a13-92a3-a4c2028988fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 1098 validated image filenames belonging to 5 classes.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/keras/preprocessing/image.py:1137: UserWarning: Found 255 invalid image filename(s) in x_col=\"path\". These filename(s) will be ignored.\n",
            "  warnings.warn(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "# 1.   Evaluate model on test set\n",
        "# 2.   NP Conversion\n",
        "# 3.   Loss and Accuracy\n",
        "\n"
      ],
      "metadata": {
        "id": "KLQrIIxkId7E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "# Set random seed for reproducibility\n",
        "np.random.seed(123)\n",
        "model = load_model('/content/drive/MyDrive/labeled_images_dataset/crb_model.h5')\n",
        "class_names = ['notch', 'infested_frond', 'infested_tree', 'healthy_frond', 'healthy_tree']\n",
        "\n",
        "# Evaluate the model on the test set\n",
        "test_generator.reset()\n",
        "y_pred = model.predict(test_generator, steps=len(test_generator), verbose=1)\n",
        "print(f'model.predict: {y_pred}')\n",
        "y_true = test_generator.classes\n",
        "\n",
        "# Convert predictions from probabilities to class indices\n",
        "y_pred = np.argmax(y_pred, axis=1)\n",
        "\n",
        "print(f'Probabilities to class indices array: {y_pred}')\n",
        "\n",
        "print(f'Shape of y_pred: {y_pred.shape}')\n",
        "\n",
        "# Evaluate the model on the test set\n",
        "test_generator.reset()\n",
        "loss, accuracy = model.evaluate(test_generator, steps=len(test_generator), verbose=2)\n",
        "print('Test Loss:', loss)\n",
        "print('Test Accuracy:', accuracy)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qoFJj4QaIf1V",
        "outputId": "ee5793ac-f65a-42b9-af77-a9b83fa3f5db"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "35/35 [==============================] - 22s 587ms/step\n",
            "model.predict: [[1.0774378e-02 4.2675366e-04 3.2745188e-01 8.5703939e-02 5.7564300e-01]\n",
            " [9.4519460e-01 5.2036025e-02 5.1819981e-04 6.2199874e-04 1.6291504e-03]\n",
            " [7.1029305e-01 4.9777780e-02 8.8216037e-02 2.9705910e-02 1.2200716e-01]\n",
            " ...\n",
            " [9.2529327e-01 7.4056908e-02 8.8848567e-05 1.6270435e-04 3.9822311e-04]\n",
            " [8.3612114e-01 5.1163107e-02 3.5673600e-02 1.8076336e-02 5.8965772e-02]\n",
            " [8.6499131e-01 7.8981072e-02 1.7045557e-02 7.9624103e-03 3.1019645e-02]]\n",
            "Probabilities to class indices array: [4 0 0 ... 0 0 0]\n",
            "Shape of y_pred: (1098,)\n",
            "35/35 - 21s - loss: 1.7775 - accuracy: 0.6129 - 21s/epoch - 586ms/step\n",
            "Test Loss: 1.7774949073791504\n",
            "Test Accuracy: 0.6129326224327087\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Generate classification report and confusion matrix"
      ],
      "metadata": {
        "id": "BXN9DNtGIiES"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import classification_report, confusion_matrix, roc_curve, auc\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "class_names = ['notch', 'infested_frond', 'infested_tree', 'healthy_frond', 'healthy_tree']\n",
        "\n",
        "# Reshape y_pred\n",
        "y_pred_reshaped = y_pred[:, np.newaxis]\n",
        "\n",
        "# Generate the classification report and confusion matrix\n",
        "report = classification_report(y_true, np.argmax(y_pred_reshaped, axis=1), target_names=class_names)\n",
        "print(report)\n",
        "\n",
        "cm = confusion_matrix(y_true, np.argmax(y_pred_reshaped, axis=1))\n",
        "fig, ax = plt.subplots(figsize=(10, 10))\n",
        "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False, ax=ax)\n",
        "ax.set_xlabel('Predicted')\n",
        "ax.set_ylabel('Actual')\n",
        "ax.set_title('Confusion Matrix')\n",
        "ax.xaxis.set_ticklabels(class_names)\n",
        "ax.yaxis.set_ticklabels(class_names)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 415
        },
        "id": "vBMNx_rUIoIX",
        "outputId": "695b2193-1c81-4125-e8d5-c8b54cfd0346"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AxisError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAxisError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-14-00b2c0926ce1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0my_pred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_pred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0my_pred_class\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_pred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# Generate the classification report and confusion matrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36margmax\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36margmax\u001b[0;34m(a, axis, out)\u001b[0m\n\u001b[1;32m   1193\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1194\u001b[0m     \"\"\"\n\u001b[0;32m-> 1195\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_wrapfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'argmax'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1196\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1197\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36m_wrapfunc\u001b[0;34m(obj, method, *args, **kwds)\u001b[0m\n\u001b[1;32m     55\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     56\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 57\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mbound\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     58\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     59\u001b[0m         \u001b[0;31m# A TypeError occurs if the object does have such a method in its\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAxisError\u001b[0m: axis 2 is out of bounds for array of dimension 2"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tqdm import tqdm\n",
        "# Generate the AUC-ROC curve\n",
        "fpr = dict()\n",
        "tpr = dict()\n",
        "roc_auc = dict()\n",
        "num_classes = 5 # notch, infested_frond, infested_tree, healthy_frond, healthy_tree\n",
        "for i in tqdm(range(num_classes), desc='Computing ROC curve'):\n",
        "    fpr[i], tpr[i], _ = roc_curve(y_true == i, y_pred[:, i])\n",
        "    roc_auc[i] = auc(fpr[i], tpr[i])"
      ],
      "metadata": {
        "id": "RiQkrSCeKZbk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 381
        },
        "outputId": "5e22946a-43a0-433a-d0d4-d958c7f54f37"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Computing ROC curve:   0%|          | 0/5 [00:00<?, ?it/s]\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-16-07ef477601e3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mnum_classes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m \u001b[0;31m# notch, infested_frond, infested_tree, healthy_frond, healthy_tree\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_classes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Computing ROC curve'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m     \u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_true\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m     \u001b[0mroc_auc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mauc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_ranking.py\u001b[0m in \u001b[0;36mroc_curve\u001b[0;34m(y_true, y_score, pos_label, sample_weight, drop_intermediate)\u001b[0m\n\u001b[1;32m    960\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    961\u001b[0m     \"\"\"\n\u001b[0;32m--> 962\u001b[0;31m     fps, tps, thresholds = _binary_clf_curve(\n\u001b[0m\u001b[1;32m    963\u001b[0m         \u001b[0my_true\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_score\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_label\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpos_label\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msample_weight\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    964\u001b[0m     )\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_ranking.py\u001b[0m in \u001b[0;36m_binary_clf_curve\u001b[0;34m(y_true, y_score, pos_label, sample_weight)\u001b[0m\n\u001b[1;32m    727\u001b[0m     \"\"\"\n\u001b[1;32m    728\u001b[0m     \u001b[0;31m# Check to make sure y_true is valid\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 729\u001b[0;31m     \u001b[0my_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtype_of_target\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    730\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0my_type\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"binary\"\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0my_type\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"multiclass\"\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mpos_label\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    731\u001b[0m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"{0} format is not supported\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_type\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/sklearn/utils/multiclass.py\u001b[0m in \u001b[0;36mtype_of_target\u001b[0;34m(y)\u001b[0m\n\u001b[1;32m    268\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    269\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mvalid\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 270\u001b[0;31m         raise ValueError(\n\u001b[0m\u001b[1;32m    271\u001b[0m             \u001b[0;34m\"Expected array-like (array or non-string sequence), got %r\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    272\u001b[0m         )\n",
            "\u001b[0;31mValueError\u001b[0m: Expected array-like (array or non-string sequence), got False"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Compute micro-average ROC curve and ROC area\n",
        "fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(label_binarize(y_true, classes=range(num_classes)).ravel(), y_pred.ravel())\n",
        "roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])"
      ],
      "metadata": {
        "id": "MuZ1_DyJKb5L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot ROC curve for each class\n",
        "plt.figure()\n",
        "lw = 2\n",
        "colors = cycle(['aqua', 'darkorange', 'cornflowerblue', 'green', 'red'])\n",
        "for i, color in zip(range(num_classes), colors):\n",
        "    plt.plot(fpr[i], tpr[i], color=color, lw=lw, label='ROC curve of class {0} (area = {1:0.2f})'.format(i, roc_auc[i]))\n",
        "    \n",
        "plt.plot(fpr[\"micro\"], tpr[\"micro\"], color='deeppink', lw=lw, linestyle='--',\n",
        "         label='micro-average ROC curve (area = {0:0.2f})'.format(roc_auc[\"micro\"]))\n",
        "\n",
        "plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n",
        "plt.xlim([0.0, 1.0])\n",
        "plt.ylim([0.0, 1.05])\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.title('Receiver Operating Characteristic (ROC)')\n",
        "plt.legend(loc=\"lower right\")\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "3n6PxSBbKgrD"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}