Custom-object-detection-with-YOLOv8/-Kaggle- Ant and Insect detector-train.ipynb

{
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.12",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    }
  },
  "nbformat_minor": 0,
  "nbformat": 4,
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "<div align=\"center\">\n",
        "\n",
        "# YOLOv8 Custom Object Detection : Model Training on Custom Data\n",
        "\n",
        "</div>\n",
        "\n",
        "Welcome to this Kaggle notebook for YOLOv8 Custom Object Detection! In this notebook, we will cover the process of training a custom object detection model on a dataset of ants and insects. Using YOLOv8, we will explore the steps involved in custom object detection. With the tools provided in this Colab, you'll be able to follow along and gain valuable insights into the world of object detection. Let's get started!"
      ],
      "metadata": {
        "id": "D7ZHY87JWdmr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import shutil\n",
        "\n",
        "def delete_directory_contents(directory_path = os.getcwd()):\n",
        "    for filename in os.listdir(directory_path):\n",
        "        file_path = os.path.join(directory_path, filename)\n",
        "        try:\n",
        "            if os.path.isfile(file_path) or os.path.islink(file_path):\n",
        "                os.unlink(file_path)\n",
        "            elif os.path.isdir(file_path):\n",
        "                shutil.rmtree(file_path)\n",
        "        except Exception as e:\n",
        "            print('Failed to delete %s. Reason: %s' % (file_path, e))\n",
        "\n",
        "delete_directory_contents()\n"
      ],
      "metadata": {
        "id": "LOzdRzXcr79f"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Importing libraries, modules and files"
      ],
      "metadata": {
        "id": "suNEhwyMPFle"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Downloading annotations and metadata for training, validation and (optional) testing."
      ],
      "metadata": {
        "id": "9d8RRUoDPZ2G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# training annotations and metadata\n",
        "!wget https://storage.googleapis.com/openimages/v6/oidv6-train-annotations-bbox.csv"
      ],
      "metadata": {
        "id": "lfpRYJb_Za2j",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:19:18.284856Z",
          "iopub.execute_input": "2023-04-15T13:19:18.285314Z",
          "iopub.status.idle": "2023-04-15T13:19:30.911370Z",
          "shell.execute_reply.started": "2023-04-15T13:19:18.285284Z",
          "shell.execute_reply": "2023-04-15T13:19:30.910146Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "259b5a64-7926-4d27-8a69-6fcae28fb0ad"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2023-04-18 14:07:43--  https://storage.googleapis.com/openimages/v6/oidv6-train-annotations-bbox.csv\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 142.250.141.128, 142.251.2.128, 74.125.137.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|142.250.141.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 2258447590 (2.1G) [text/csv]\n",
            "Saving to: ‘oidv6-train-annotations-bbox.csv’\n",
            "\n",
            "oidv6-train-annotat 100%[===================>]   2.10G   159MB/s    in 15s     \n",
            "\n",
            "2023-04-18 14:07:58 (140 MB/s) - ‘oidv6-train-annotations-bbox.csv’ saved [2258447590/2258447590]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# validation annotations and metadata\n",
        "!wget https://storage.googleapis.com/openimages/v5/validation-annotations-bbox.csv"
      ],
      "metadata": {
        "id": "W9L3sOH_bqNm",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:19:30.913226Z",
          "iopub.execute_input": "2023-04-15T13:19:30.914690Z",
          "iopub.status.idle": "2023-04-15T13:19:32.127575Z",
          "shell.execute_reply.started": "2023-04-15T13:19:30.914646Z",
          "shell.execute_reply": "2023-04-15T13:19:32.126243Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c59d040e-2f78-4bb7-ca2c-d28f7b781c2a"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2023-04-18 14:07:58--  https://storage.googleapis.com/openimages/v5/validation-annotations-bbox.csv\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 142.250.141.128, 142.251.2.128, 74.125.137.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|142.250.141.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 25105048 (24M) [text/csv]\n",
            "Saving to: ‘validation-annotations-bbox.csv’\n",
            "\n",
            "validation-annotati 100%[===================>]  23.94M  --.-KB/s    in 0.1s    \n",
            "\n",
            "2023-04-18 14:07:59 (175 MB/s) - ‘validation-annotations-bbox.csv’ saved [25105048/25105048]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# testing annotations and metadata\n",
        "!wget https://storage.googleapis.com/openimages/v5/test-annotations-bbox.csv"
      ],
      "metadata": {
        "id": "Kz2L_G7vbr1U",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:19:32.129771Z",
          "iopub.execute_input": "2023-04-15T13:19:32.130193Z",
          "iopub.status.idle": "2023-04-15T13:19:39.688593Z",
          "shell.execute_reply.started": "2023-04-15T13:19:32.130151Z",
          "shell.execute_reply": "2023-04-15T13:19:39.687250Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b5eb3de4-90c6-4f36-fb97-9106f224dfa4"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2023-04-18 14:07:59--  https://storage.googleapis.com/openimages/v5/test-annotations-bbox.csv\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 142.250.141.128, 142.251.2.128, 74.125.137.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|142.250.141.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 77484237 (74M) [text/csv]\n",
            "Saving to: ‘test-annotations-bbox.csv’\n",
            "\n",
            "test-annotations-bb 100%[===================>]  73.89M   148MB/s    in 0.5s    \n",
            "\n",
            "2023-04-18 14:07:59 (148 MB/s) - ‘test-annotations-bbox.csv’ saved [77484237/77484237]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Importing the github repository of the project "
      ],
      "metadata": {
        "id": "fMGGcvfDQreC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!git clone https://github.com/mohamedamine99/YOLOv8-custom-object-detection"
      ],
      "metadata": {
        "id": "1u8w3YWBYU1e",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:19:39.690850Z",
          "iopub.execute_input": "2023-04-15T13:19:39.691255Z",
          "iopub.status.idle": "2023-04-15T13:19:44.366162Z",
          "shell.execute_reply.started": "2023-04-15T13:19:39.691213Z",
          "shell.execute_reply": "2023-04-15T13:19:44.364882Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Downloading the `downloader.py` file used later to download the dataset from OpenImages"
      ],
      "metadata": {
        "id": "lQwt-_CtQ0f_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!wget https://raw.githubusercontent.com/openimages/dataset/master/downloader.py"
      ],
      "metadata": {
        "id": "_8cgZXaeqS3e",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:20:17.689744Z",
          "iopub.execute_input": "2023-04-15T13:20:17.690812Z",
          "iopub.status.idle": "2023-04-15T13:20:18.975767Z",
          "shell.execute_reply.started": "2023-04-15T13:20:17.690773Z",
          "shell.execute_reply": "2023-04-15T13:20:18.974482Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Importing and installing required libraries and modules"
      ],
      "metadata": {
        "id": "16ZQQWJ5RU38"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# required by the downloader.py file\n",
        "!pip install boto3"
      ],
      "metadata": {
        "id": "A18gaNfgq30E",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:20:18.977686Z",
          "iopub.execute_input": "2023-04-15T13:20:18.978429Z",
          "iopub.status.idle": "2023-04-15T13:20:33.733004Z",
          "shell.execute_reply.started": "2023-04-15T13:20:18.978366Z",
          "shell.execute_reply": "2023-04-15T13:20:33.731750Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import shutil\n",
        "\n",
        "# install and import pyyaml used to create custom config files for training\n",
        "%pip install pyyaml\n",
        "import yaml\n"
      ],
      "metadata": {
        "id": "n537TujpYaXV",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:19:05.687331Z",
          "iopub.execute_input": "2023-04-15T13:19:05.687703Z",
          "iopub.status.idle": "2023-04-15T13:19:18.217834Z",
          "shell.execute_reply.started": "2023-04-15T13:19:05.687669Z",
          "shell.execute_reply": "2023-04-15T13:19:18.216442Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "183bf0b6-dc1f-4e45-ea1d-4c9efbf1fdba"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: pyyaml in /usr/local/lib/python3.9/dist-packages (6.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Data preprocessing"
      ],
      "metadata": {
        "id": "-0vIemq3R-9E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# This fuction is used to create a custom YAML file which is used later to configure training data\n",
        "def create_yolo_yaml_config(yaml_filepath, dataset_path, dataset_labels):\n",
        "\n",
        "    data = {'path':dataset_path,\n",
        "            'train': os.path.join('images', 'train'),\n",
        "            'val': os.path.join('images', 'validation'),\n",
        "            'names':{i:label for i, label in enumerate(dataset_labels)}\n",
        "            }\n",
        "\n",
        "    # Save the changes to the file\n",
        "    with open(yaml_filepath, 'w') as fp:\n",
        "    # set sort_keys = False to preserve the order of keys\n",
        "        yaml.dump(data, fp, sort_keys=False)\n",
        "\n"
      ],
      "metadata": {
        "id": "2gsRTntkgRW3",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:19:18.247623Z",
          "iopub.execute_input": "2023-04-15T13:19:18.248070Z",
          "iopub.status.idle": "2023-04-15T13:19:18.254744Z",
          "shell.execute_reply.started": "2023-04-15T13:19:18.248032Z",
          "shell.execute_reply": "2023-04-15T13:19:18.253576Z"
        },
        "trusted": true
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# This function returns a dict with the names and IDs of selected object we want to train our model to detect\n",
        "def get_class_id(classes_file, class_names):\n",
        "    id_name_dict = {}\n",
        "    with open(classes_file, 'r') as f:\n",
        "        for line in f:\n",
        "            id, label = line.split(',')\n",
        "            label = label.strip()\n",
        "            #print(label)\n",
        "            if label in class_names:\n",
        "                print(label)\n",
        "                id_name_dict[label] = id\n",
        "        \n",
        "    return id_name_dict"
      ],
      "metadata": {
        "id": "K0hykIT2hRNv",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:19:18.257689Z",
          "iopub.execute_input": "2023-04-15T13:19:18.258369Z",
          "iopub.status.idle": "2023-04-15T13:19:18.267145Z",
          "shell.execute_reply.started": "2023-04-15T13:19:18.258333Z",
          "shell.execute_reply": "2023-04-15T13:19:18.265995Z"
        },
        "trusted": true
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Downloading Images and Labels for YOLOv8 Model Training on Target Objects"
      ],
      "metadata": {
        "id": "7GKfX3gs9qaH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Target objects to be detected\n",
        "names = ['Ant', 'Insect']\n",
        "\n",
        "# path to the dataset directory (recommended to use absolute path)\n",
        "dataset_path = os.path.abspath(os.path.join('.', 'data')) \n",
        "\n",
        "# path to the YAML file that contains training configuration\n",
        "yaml_filepath = os.path.join('.', 'config.yaml')\n",
        "\n",
        "# Create a custom YAML config file based on the above selected target objects and dataset path\n",
        "create_yolo_yaml_config(yaml_filepath, dataset_path, names)"
      ],
      "metadata": {
        "execution": {
          "iopub.status.busy": "2023-04-15T13:19:44.371282Z",
          "iopub.execute_input": "2023-04-15T13:19:44.371711Z",
          "iopub.status.idle": "2023-04-15T13:19:44.381041Z",
          "shell.execute_reply.started": "2023-04-15T13:19:44.371675Z",
          "shell.execute_reply": "2023-04-15T13:19:44.379816Z"
        },
        "trusted": true,
        "id": "JfTHp0VQG1_k"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# get the class IDs of the target objects, all detectable objects and their IDs \n",
        "# are pre-determined by OpenImage in class-descriptions-boxable.csv file\n",
        "class_ids = get_class_id('./YOLOv8-custom-object-detection/class-descriptions-boxable.csv'\n",
        "                         ,names)\n",
        "print(class_ids)\n",
        "print(names)"
      ],
      "metadata": {
        "execution": {
          "iopub.status.busy": "2023-04-15T13:19:44.382852Z",
          "iopub.execute_input": "2023-04-15T13:19:44.383472Z",
          "iopub.status.idle": "2023-04-15T13:19:44.391740Z",
          "shell.execute_reply.started": "2023-04-15T13:19:44.383405Z",
          "shell.execute_reply": "2023-04-15T13:19:44.390610Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "twhs19WGG1_l",
        "outputId": "08cd6fa3-e8ce-4568-eae9-1e16f9a4a1a3"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Insect\n",
            "Ant\n",
            "{'Insect': '/m/03vt0', 'Ant': '/m/0_k2'}\n",
            "['Ant', 'Insect']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a list of annotated images to be downloaded by the downloader script download.py\n",
        "# the list is a text file in the following format : $SPLIT/$IMAGE_ID\n",
        "# example : \n",
        "# train/f9e0434389a1d4dd\n",
        "# train/1a007563ebc18664\n",
        "\n",
        "\n",
        "train_bboxes_filename = os.path.join('.', 'oidv6-train-annotations-bbox.csv')\n",
        "validation_bboxes_filename = os.path.join('.', 'validation-annotations-bbox.csv')\n",
        "test_bboxes_filename = os.path.join('.', 'test-annotations-bbox.csv')\n",
        "\n",
        "image_list_file_path = os.path.join('.', 'image_list_file.txt')\n",
        "\n",
        "image_list_file_list = []\n",
        "for j, filename in enumerate([train_bboxes_filename, validation_bboxes_filename, test_bboxes_filename]):\n",
        "    print(filename)\n",
        "    with open(filename, 'r') as f:\n",
        "        line = f.readline()\n",
        "        while len(line) != 0:\n",
        "            id, _, class_name, _, x1, x2, y1, y2, _, _, _, _, _ = line.split(',')[:13]\n",
        "            if class_name in list(class_ids.values()) and id not in image_list_file_list:\n",
        "                image_list_file_list.append(id)\n",
        "                with open(image_list_file_path, 'a') as fw:\n",
        "                    fw.write('{}/{}\\n'.format(['train', 'validation', 'test'][j], id))\n",
        "            line = f.readline()\n",
        "\n",
        "        f.close()"
      ],
      "metadata": {
        "id": "jvXQcL5gaagR",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:19:44.393039Z",
          "iopub.execute_input": "2023-04-15T13:19:44.393659Z",
          "iopub.status.idle": "2023-04-15T13:20:17.688273Z",
          "shell.execute_reply.started": "2023-04-15T13:19:44.393622Z",
          "shell.execute_reply": "2023-04-15T13:20:17.687176Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "804500e9-2645-43e3-aa09-6da100d45953"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "./oidv6-train-annotations-bbox.csv\n",
            "./validation-annotations-bbox.csv\n",
            "./test-annotations-bbox.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "DATA_ALL_DIR = os.path.join('.', 'data_all') # directory that contains all downloaded data selected from the list\n",
        "DATA_OUT_DIR = os.path.join('.', 'data') # directory that contains data reorganized in YOLO format\n",
        "os.makedirs(DATA_ALL_DIR)\n",
        "os.makedirs(DATA_OUT_DIR)"
      ],
      "metadata": {
        "id": "vFzF-GDNYU1g",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:20:33.734927Z",
          "iopub.execute_input": "2023-04-15T13:20:33.735681Z",
          "iopub.status.idle": "2023-04-15T13:20:33.745673Z",
          "shell.execute_reply.started": "2023-04-15T13:20:33.735636Z",
          "shell.execute_reply": "2023-04-15T13:20:33.743848Z"
        },
        "trusted": true
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# run the donwloader script in order to download data related to the target objects \n",
        "# and according to the image_list_file.txt\n",
        "!python downloader.py ./image_list_file.txt --download_folder=./data_all --num_processes=5"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9yozb9s3qfNC",
        "outputId": "4e55eb3f-5ea4-42c2-cdf4-a58b3cc46157",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:20:33.746779Z",
          "iopub.execute_input": "2023-04-15T13:20:33.747232Z",
          "iopub.status.idle": "2023-04-15T13:24:18.963395Z",
          "shell.execute_reply.started": "2023-04-15T13:20:33.747196Z",
          "shell.execute_reply": "2023-04-15T13:24:18.962156Z"
        },
        "trusted": true
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading images: 100% 7430/7430 [05:38<00:00, 21.94it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Re-structuring the Dataset in YOLO-Compatible Format"
      ],
      "metadata": {
        "id": "j-HXHEGK9KzS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a dataset in the yolo format with two main directories : images and labels\n",
        "# each containing train and validation data \n",
        "\n",
        "\n",
        "# Create the empty dataset in yolo format\n",
        "for dir_ in ['images', 'labels']:\n",
        "    for set_ in ['train', 'validation', 'test']:\n",
        "        new_dir = os.path.join(DATA_OUT_DIR, dir_, set_)\n",
        "        if os.path.exists(new_dir):\n",
        "            shutil.rmtree(new_dir)\n",
        "        os.makedirs(new_dir)\n"
      ],
      "metadata": {
        "id": "s_m7OhMPmWOg",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:24:18.967254Z",
          "iopub.execute_input": "2023-04-15T13:24:18.967603Z",
          "iopub.status.idle": "2023-04-15T13:24:18.975091Z",
          "shell.execute_reply.started": "2023-04-15T13:24:18.967570Z",
          "shell.execute_reply": "2023-04-15T13:24:18.974077Z"
        },
        "trusted": true
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Fill the dataset with the appropriate images and labels in the appropriate format\n",
        "\n",
        "for j, filename in enumerate([train_bboxes_filename, validation_bboxes_filename, test_bboxes_filename]):\n",
        "    set_ = ['train', 'validation', 'test'][j]\n",
        "    print(filename)\n",
        "    with open(filename, 'r') as f:\n",
        "        line = f.readline()\n",
        "        while len(line) != 0:\n",
        "            id, _, class_name, _, x1, x2, y1, y2, _, _, _, _, _ = line.split(',')[:13]\n",
        "            if class_name in list(class_ids.values()):\n",
        "\n",
        "                if not os.path.exists(os.path.join(DATA_OUT_DIR, 'images', set_, '{}.jpg'.format(id))):\n",
        "\n",
        "                    shutil.copy(os.path.join(DATA_ALL_DIR, '{}.jpg'.format(id)),\n",
        "                                os.path.join(DATA_OUT_DIR, 'images', set_, '{}.jpg'.format(id)))\n",
        "                    \n",
        "                with open(os.path.join(DATA_OUT_DIR, 'labels', set_, '{}.txt'.format(id)), 'a') as f_ann:\n",
        "                    # class_id, xc, yx, w, h\n",
        "                    # \n",
        "                    x1, x2, y1, y2 = [float(j) for j in [x1, x2, y1, y2]]\n",
        "                    xc = (x1 + x2) / 2\n",
        "                    yc = (y1 + y2) / 2\n",
        "                    w = x2 - x1\n",
        "                    h = y2 - y1\n",
        "                    \n",
        "                    # class id = 0 if 'Ant' and 1 if 'Insect'\n",
        "                    name = [k for k, v in class_ids.items() if v == class_name][0]\n",
        "                    class_id = names.index(name)\n",
        "                    \n",
        "                    #*****\n",
        "                    f_ann.write('{} {} {} {} {}\\n'.format(class_id, xc, yc, w, h))\n",
        "                    f_ann.close()\n",
        "\n",
        "            line = f.readline()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B3cn6xkm2Al3",
        "outputId": "0fa08d2b-7272-4acd-8efd-c5ad7acb737a",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:24:18.976851Z",
          "iopub.execute_input": "2023-04-15T13:24:18.977350Z",
          "iopub.status.idle": "2023-04-15T13:24:58.703974Z",
          "shell.execute_reply.started": "2023-04-15T13:24:18.977314Z",
          "shell.execute_reply": "2023-04-15T13:24:58.702765Z"
        },
        "trusted": true
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "./oidv6-train-annotations-bbox.csv\n",
            "./validation-annotations-bbox.csv\n",
            "./test-annotations-bbox.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Training the object detection model"
      ],
      "metadata": {
        "id": "WigCyDSDWLiF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%pip install ultralytics\n",
        "import ultralytics\n",
        "ultralytics.checks()"
      ],
      "metadata": {
        "id": "LpzPSI1q2Zxz",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:24:58.706674Z",
          "iopub.execute_input": "2023-04-15T13:24:58.707092Z",
          "iopub.status.idle": "2023-04-15T13:25:16.976664Z",
          "shell.execute_reply.started": "2023-04-15T13:24:58.707050Z",
          "shell.execute_reply": "2023-04-15T13:25:16.975505Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from ultralytics import YOLO\n",
        "\n",
        "\n",
        "# Load a model\n",
        "model = YOLO(\"yolov8n.pt\")  \n",
        "\n",
        "# Use the model for training\n",
        "results = model.train(data='./config.yaml', \n",
        "                      epochs=150)  # train the model\n"
      ],
      "metadata": {
        "id": "cCnadnO1psAW",
        "execution": {
          "iopub.status.busy": "2023-04-15T13:25:16.978934Z",
          "iopub.execute_input": "2023-04-15T13:25:16.980165Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Preparing results for download"
      ],
      "metadata": {
        "id": "fNSLQYHvWU7c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!zip -r train_results.zip ./runs"
      ],
      "metadata": {
        "id": "4uwMaB_C8VoL",
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}