07a_YOLOv8_Amonites_20240323.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "gpuType": "T4",
      "authorship_tag": "ABX9TyN2FwVZn6Pmi+ZKwj7Qm/Ue",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sergioGarcia91/ML_and_EDA/blob/main/07a_YOLOv8_Amonites_20240323.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Detección de Objetos - Dataset: Amonites\n",
        "\n",
        "\n",
        "> *Ser tan rápidos como el más lento, \\\n",
        "> y ser tan lentos como el más rápido.*\n",
        "\n",
        "**Autor:** Sergio Andrés García Arias  \n",
        "**Versión 01:** Marzo 2024\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "7pKaC-YZ4sep"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introducción\n",
        "\n",
        "En este Notebook, abordaremos el uso de un modelo de machine learning pre-entrenado para la detección de `Amonites`, un objeto de interés específico. Utilizaremos el modelo `YOLOv8`, desarrollado por Ultralytics. La [documentación oficial](https://docs.ultralytics.com/es) de YOLOv8 proporciona información detallada y tutoriales para la modificación de sus modelos.\n",
        "\n",
        "> *El objetivo principal de este proyecto es reentrenar una Red Neuronal Convolucional (CNN) para que pueda detectar exclusivamente los nuevos objetos de interés, en este caso, los amonites.*\n",
        "\n",
        "\n",
        "---\n",
        "**Observación:** En la propia documentación y en la web se encuentran videos que ejemplifican este proceso. Todo el proceso preliminar de generación de las imágenes para el entrenamiento no se va a ejemplificar. Esta primera etapa de obtención de imágenes y generación del dataset fue realizada utilizando la herramienta suministrada por Ultralytics: [Roboflow](https://roboflow.com). Dos videos que sintetizan el trabajo de este Notebook son:\n",
        "\n",
        "- [How to train YOLOv8 Object Detection on Custom Dataset | step by step Tutorial | Google Colab](https://www.youtube.com/watch?v=ZzC3SJJifMg&t=677s)\n",
        "- [YOLOV8: Object Detection Annotation | Annotate Custom Data using Roboflow](https://www.youtube.com/watch?v=qn96xC3LV2Y)\n"
      ],
      "metadata": {
        "id": "dYQBPIm77qzd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Uso de GPU\n",
        "\n",
        "Para lograr un rendimiento óptimo y acelerar el entrenamiento de modelos de Redes Neuronales Convolucionales (CNN), es recomendable utilizar una unidad de procesamiento gráfico (GPU). La capacidad de procesamiento paralelo de las GPU permite realizar cálculos intensivos de manera más eficiente que las unidades de procesamiento central (CPU) tradicionales.\n",
        "\n",
        "Antes de comenzar el entrenamiento, es importante cambiar el entorno de ejecución para que utilice una GPU. Esto se puede hacer seleccionando:\n",
        "\n",
        "- `Entorno de ejecución` y luego `Cambiar tipo de entorno de ejecución`.\n",
        "\n",
        "\n",
        "\n",
        "<center><img src='https://github.com/sergioGarcia91/ML_and_EDA/blob/main/yolo01.png?raw=true' width=500 /></center>"
      ],
      "metadata": {
        "id": "ZstO2BDv-qNB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Limitaciones de recursos\n",
        "\n",
        "Es posible que te encuentres con la situación en la que no puedas acceder al uso de la `GPU`. Esto se puede manifestar a través de un mensaje similar al de la imagen.\n",
        "\n",
        "> *Puedes obtener información sobre las limitaciones de este entorno virtual en las [Preguntas frecuentes de Colaboratory](https://research.google.com/colaboratory/faq.html#usage-limits).*\n",
        "\n",
        "> *Hasta la fecha de la réplica de este Notebook (2024-03-25), no he podido acceder a una GPU. En fechas anteriores sí fue posible; simplemente es cuestión de tener paciencia hasta obtener una. Google ofrece la opción de pago si se va a hacer uso continuo de una GPU o recursos superiores, lo cual puede ser de interés; sin embargo, para fines ilustrativos, tener algo de paciencia y suerte es suficiente.*\n",
        "\n",
        "\n",
        "<center><img src='https://github.com/sergioGarcia91/ML_and_EDA/blob/main/yolo02.png?raw=true' width=500 /></center>\n",
        "\n"
      ],
      "metadata": {
        "id": "WMHJRl1J4uMa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Inicio"
      ],
      "metadata": {
        "id": "Zrk0AYGd4tTg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "En la web de Ultralytics, se proporciona una ejemplificación de cómo realizar la [Detección de objetos](https://docs.ultralytics.com/tasks/detect/#val). Algunos comentarios en inglés se mantienen tal como están en la documentación original, nuestra tarea es verificar que se ejecute correctamente y realizar los ajustes necesarios si es requerido. También incluiremos cualquier otra acción que sea de nuestro interés durante el proceso.\n"
      ],
      "metadata": {
        "id": "sWVXoUedAMex"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ClgrhBU660Xe"
      },
      "outputs": [],
      "source": [
        "# Instalar ultralytics\n",
        "!pip install ultralytics"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install tqdm --upgrade"
      ],
      "metadata": {
        "id": "J720jESm8bBZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2126d125-d216-42a8-c117-192b6e5f547c"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (4.66.2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar librerias requeridas\n",
        "import os\n",
        "import shutil\n",
        "import random\n",
        "\n",
        "from tqdm.notebook import tqdm"
      ],
      "metadata": {
        "id": "Jv3q9rma8BUK"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Drive"
      ],
      "metadata": {
        "id": "GAMrLtczuEl8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Conectar al Drive para cargar los Amonites\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zsq9RCCx8isq",
        "outputId": "9956de7f-7cfe-4f49-ef01-22421b23021d"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Consideraciones previas\n",
        "\n",
        "En Roboflow se delimitaron los objetos de interés, en nuestro caso, los `Amonites`, de modo que el modelo detectará solo una clase de objeto. El dataset consta de 121 imágenes, de las cuales se utilizarán 100 para el entrenamiento. De estas 100 imágenes, el $80\\%$ se utilizó para el entrenamiento y el $20\\%$ restante para la validación. La evaluación del modelo se realizó utilizando las 21 imágenes restantes que el modelo nunca ha visto.\n",
        "\n",
        "\n",
        "<center><img src='https://github.com/sergioGarcia91/ML_and_EDA/blob/main/yolo03.png?raw=true' width=1000 /></center>"
      ],
      "metadata": {
        "id": "lsdxMoA_BNI_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Ajuste del archivo YAML\n",
        "\n",
        "Antes de poder utilizar nuestro dataset preparado en Roboflow, es necesario ajustar el archivo `data.yaml` descargado del archivo comprimido. Este archivo con extensión `.yaml` se puede abrir con un editor de texto, y se deben modificar las rutas de `train:` y `val:`. La ruta de `test:` no es necesaria en este punto ya que la configuraremos manualmente más adelante. En mi caso, las rutas de entrenamiento y validación corresponden a las rutas en mi Google Drive.\n",
        "\n",
        "<center><img src='https://github.com/sergioGarcia91/ML_and_EDA/blob/main/yolo04.png?raw=true' width=700 /></center>\n",
        "\n"
      ],
      "metadata": {
        "id": "D3KQ-Qv7Caqe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Cargar modelo base"
      ],
      "metadata": {
        "id": "YPvf2q2euHEU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import ultralytics\n",
        "ultralytics.checks()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jb0m69rV-ZAG",
        "outputId": "086c44c7-02bb-4f13-dfd3-5b90bc93e208"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ultralytics YOLOv8.1.34 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
            "Setup complete ✅ (2 CPUs, 12.7 GB RAM, 28.9/78.2 GB disk)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load a model\n",
        "model = ultralytics.YOLO('yolov8n.yaml')  # build a new model from YAML\n",
        "model = ultralytics.YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)\n",
        "model = ultralytics.YOLO('yolov8n.yaml').load('yolov8n.pt')  # build from YAML and transfer weights"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zODqW3Q0_Enx",
        "outputId": "b5f426f0-eb6e-4589-c399-cc00df739f4a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Transferred 355/355 items from pretrained weights\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Entrenar"
      ],
      "metadata": {
        "id": "sn--C7FOuJ_t"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A partir de este punto, después de cargar el modelo y entrenarlo, es posible que en el panel izquierdo, en la sección de `Archivos` identificada con el símbolo de la carpeta, se cree una nueva carpeta donde se almacenarán algunos archivos importantes para observar el comportamiento del modelo.\n"
      ],
      "metadata": {
        "id": "c4hVe96uJIwY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# en pathYaml se coloca la ruta del archivo yaml generado al descargar las\n",
        "# imágenes ya listas para el entrenamiento de Robotflow\n",
        "pathYaml = '/content/drive/MyDrive/UIS/ASIGNATURAS/Notebooks_Python/Yolo_Amonite/Ammonite.v2i.yolov8/data.yaml'\n",
        "\n",
        "# Train the model\n",
        "results = model.train(data=pathYaml, epochs=200, imgsz=640)"
      ],
      "metadata": {
        "id": "CXdfjRFS_yWG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Predecir"
      ],
      "metadata": {
        "id": "y2ZQMiEvuMOZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Predecir\n",
        "# Load a model\n",
        "pathModelo = '/content/drive/MyDrive/UIS/ASIGNATURAS/Notebooks_Python/Yolo_Amonite/Resultados/runs/detect/train6/weights/best.pt'\n",
        "model = ultralytics.YOLO(pathModelo)  # load a custom model\n",
        "\n",
        "# Predict with the model\n",
        "pathTest = '/content/drive/MyDrive/UIS/ASIGNATURAS/Notebooks_Python/Yolo_Amonite/21_imag_test'\n",
        "results = model.predict(pathTest, conf=0.05, imgsz=640)  # predict on an image\n"
      ],
      "metadata": {
        "id": "xOj0si4-CaNa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Los pesos del modelo entrenado están disponibles para su descarga en el siguiente enlace: [PesosAmonites_YOLOv8.pt](https://github.com/sergioGarcia91/ML_and_EDA/blob/21fcfbfb329ea553e530feb2ab52f73954c88e38/PesosAmonites_YOLOv8.pt)."
      ],
      "metadata": {
        "id": "A4RiagQF06uy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Guardar figuras"
      ],
      "metadata": {
        "id": "IKREx3wJuOhk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Process results list\n",
        "# Para guardar los resultados de las 21 imágenes que no ha visto la CNN\n",
        "id = 1\n",
        "pathSave = '/content/drive/MyDrive/UIS/ASIGNATURAS/Notebooks_Python/Yolo_Amonite/Resultados/'\n",
        "for result in results:\n",
        "    boxes = result.boxes  # Boxes object for bounding box outputs\n",
        "    masks = result.masks  # Masks object for segmentation masks outputs\n",
        "    keypoints = result.keypoints  # Keypoints object for pose outputs\n",
        "    probs = result.probs  # Probs object for classification outputs\n",
        "    result.show()  # display to screen\n",
        "    result.save(filename=pathSave+f'result_{id}.jpg')  # save to disk\n",
        "    id += 1"
      ],
      "metadata": {
        "id": "QsGWFmbVI3yV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Algunos resultados:\n",
        "\n",
        "<img src=\"https://github.com/sergioGarcia91/ML_and_EDA/blob/main/result_1.jpg?raw=true\" alt=\"Amonite 1\" width=\"500\" >\n",
        "<img src=\"https://github.com/sergioGarcia91/ML_and_EDA/blob/main/result_2.jpg?raw=true\" alt=\"Amonite 2\" width=\"500\" >\n",
        "<img src=\"https://github.com/sergioGarcia91/ML_and_EDA/blob/main/result_12.jpg?raw=true\" alt=\"Amonite 12\" width=\"500\" >\n",
        "<img src=\"https://github.com/sergioGarcia91/ML_and_EDA/blob/main/result_21.jpg?raw=true\" alt=\"Amonite 21\" width=\"500\" >\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "vuSBbuxRPyth"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Videos"
      ],
      "metadata": {
        "id": "pg988pt1uRNN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ahora, lo interesante es ver el resultado de dos videos que utilicé:\n",
        "\n",
        "1. El primer video es una grabación de la pantalla de mi [Navegador](https://www.youtube.com/watch?v=77b0GASeQn8) en la cual realicé una consulta en Google sobre `Amonites`.\n",
        "2. El segundo video está grabado con mi [Celular](https://www.youtube.com/shorts/M7yWYOKWsNM) que muestra algunas muestras que tengo, incluyendo unos `Amonites`.\n"
      ],
      "metadata": {
        "id": "rFBq4gtiJ36H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Predecir videos\n",
        "# Load a model\n",
        "pathModelo = '/content/drive/MyDrive/UIS/ASIGNATURAS/Notebooks_Python/Yolo_Amonite/Resultados/runs/detect/train6/weights/best.pt'\n",
        "model = ultralytics.YOLO(pathModelo)  # load a custom model\n",
        "\n",
        "# Predict with the model\n",
        "pathVideo1 = '/content/drive/MyDrive/UIS/ASIGNATURAS/Notebooks_Python/Yolo_Amonite/navegador.mkv'\n",
        "results = model.predict(pathVideo1, conf=0.35, imgsz=640, save=True)  # predict on an image"
      ],
      "metadata": {
        "id": "9eYzZXY3WE0A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Predecir videos\n",
        "# Load a model\n",
        "pathModelo = '/content/drive/MyDrive/UIS/ASIGNATURAS/Notebooks_Python/Yolo_Amonite/Resultados/runs/detect/train6/weights/best.pt'\n",
        "model = ultralytics.YOLO(pathModelo)  # load a custom model\n",
        "\n",
        "# Predict with the model\n",
        "pathVideo2 = '/content/drive/MyDrive/UIS/ASIGNATURAS/Notebooks_Python/Yolo_Amonite/celular.mp4'\n",
        "results = model.predict(pathVideo2, conf=0.05, imgsz=640, save=True)  # predict on an image"
      ],
      "metadata": {
        "id": "hlCwy4hlXMJz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "El resultado puede considerarse aceptable ya que logra detectar los amonites. Sin embargo, no logra detectar todos, lo cual puede atribuirse principalmente a que se realizó un entrenamiento con solo 100 imágenes. Para mejorar la detección, sería necesario aumentar la cantidad de imágenes utilizadas en el entrenamiento, y para ello se puede emplear la técnica de aumento de datos. Esta opción de aumento de datos está disponible directamente en Roboflow.\n",
        "\n",
        "---\n",
        "Algunas recomendaciones adicionales para mejorar la detección de objetos:\n",
        "\n",
        "1. **Variedad en los datos:** Asegúrate de incluir una amplia variedad de imágenes que representen diferentes aspectos y variaciones de los objetos, como diferentes ángulos, tamaños, colores de fondo, iluminación, etc. Esto ayudará al modelo a generalizar mejor y detectar los amonites en diversas condiciones.\n",
        "\n",
        "2. **Calidad de las imágenes:** Utiliza imágenes de alta calidad y resolución para el entrenamiento. Imágenes borrosas o de baja calidad pueden afectar la capacidad del modelo para detectar correctamente los objetos. Aunque tal vez usar imágenes de baja calidad sea posible, estas deben ser lo suficientemente representativas para identificar el objeto.\n",
        "\n",
        "3. **Etiquetado preciso:** Asegúrate de etiquetar correctamente las imágenes de entrenamiento para que el modelo aprenda con precisión las características de los objetos.\n",
        "\n",
        "4. **Ajuste de hiperparámetros:** Experimenta con diferentes hiperparámetros durante el entrenamiento, como el tamaño del lote, la tasa de aprendizaje, el número de épocas, etc. Estos ajustes pueden tener un impacto significativo en el rendimiento del modelo.\n",
        "\n",
        "5. **Validación cruzada:** Utiliza técnicas de validación cruzada para evaluar el rendimiento del modelo de manera más rigurosa y garantizar que no esté sobreajustado a los datos de entrenamiento.\n",
        "\n",
        "6. **Revisión del modelo:** Después del entrenamiento, realiza una revisión exhaustiva del modelo para identificar cualquier área de mejora o posibles errores en la detección. Ajusta y vuelve a entrenar el modelo según sea necesario.\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "PqXP_8cBOgix"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exportar a TFlite"
      ],
      "metadata": {
        "id": "fssO2gT9ubuP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install 'tensorflow<2.14.0' ultralytics"
      ],
      "metadata": {
        "id": "gC-NwMeNyKtr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import ultralytics\n",
        "\n",
        "# Load a model\n",
        "pathModelo = '/content/drive/MyDrive/UIS/ASIGNATURAS/Notebooks_Python/Yolo_Amonite/Resultados/runs/detect/train6/weights/best.pt'\n",
        "model = ultralytics.YOLO(pathModelo)  # load a custom model\n",
        "\n",
        "# Export the model\n",
        "model.export(format='tflite')"
      ],
      "metadata": {
        "id": "HSND3gRJud8X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Copiar carpetas"
      ],
      "metadata": {
        "id": "5EDNBH8zuTdf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import locale\n",
        "locale.getpreferredencoding = lambda: \"UTF-8\""
      ],
      "metadata": {
        "id": "vBiJhTnpOJSf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!cp -r /content/runs /content/drive/MyDrive/UIS/ASIGNATURAS/Notebooks_Python/Yolo_Amonite/Resultados"
      ],
      "metadata": {
        "id": "1KE9v5YqMsy4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Extras"
      ],
      "metadata": {
        "id": "kor0K6cIuWiG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Predecir imagen web\n",
        "# Load a model\n",
        "model = ultralytics.YOLO('/content/runs/detect/train6/weights/best.pt')  # load a custom model\n",
        "\n",
        "# Predict with the model\n",
        "urlImag = 'https://whalerslocker.com/cdn/shop/articles/6.5_-Ammonite-Fossil-Split-Pair_1200x1200.jpg'\n",
        "results = model.predict(urlImag, conf=0.35, imgsz=640, save=True, show=True)  # predict on an image"
      ],
      "metadata": {
        "id": "CjDRUPA6Qe26"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fin"
      ],
      "metadata": {
        "id": "dnYoaFmxuZI_"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "1Gy1z5YDuajW"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}