Detective de enfermedades de plantas de Monk Guía para la salud de las plantas impulsada por IA

Detective de enfermedades de plantas Guía para la salud de las plantas impulsada por IA de Monk

Introducción

La agricultura es la vida de nuestra civilización, proporcionando alimento y sustento a miles de millones de personas en todo el mundo. Sin embargo, esta industria vital se enfrenta a un adversario implacable: las enfermedades de las plantas. Estas amenazas microscópicas pueden causar estragos en los cultivos, provocando pérdidas económicas significativas y escasez de alimentos. La clave para salvaguardar nuestro patrimonio agrícola radica en la detección temprana y la intervención oportuna, donde entra en juego la tecnología de vanguardia. Esta guía exhaustiva emprenderá un viaje hacia la clasificación de enfermedades de las plantas utilizando Monk, una poderosa biblioteca de aprendizaje automático. Al final de este artículo, estarás equipado con los conocimientos para aprovechar el potencial de la inteligencia artificial en la identificación y el combate eficaz de las enfermedades de las plantas.

Así que abróchate el cinturón mientras exploramos cómo Monk nos capacita para crear, entrenar y optimizar modelos de aprendizaje profundo para la clasificación de enfermedades de las plantas. Pero antes de sumergirnos en los aspectos técnicos, vamos a preparar el escenario entendiendo la importancia de este esfuerzo y por qué Monk desempeña un papel fundamental.

Objetivos de aprendizaje

Comprender los fundamentos del software/biblioteca Monk.
Aprender cómo instalar y configurar Monk en tu máquina local o entorno de desarrollo preferido.
Explorar la importancia de los datos de alta calidad en el aprendizaje automático.
Aprender cómo adquirir, preprocesar y organizar conjuntos de datos de imágenes de enfermedades de las plantas para tareas de clasificación utilizando Monk.
Obtener información sobre la selección de arquitecturas de modelos de aprendizaje profundo adecuadas para la clasificación de enfermedades de las plantas.
Entender cómo configurar y afinar modelos dentro de Monk, incluyendo modelos pre-entrenados para el aprendizaje por transferencia.

Este artículo fue publicado como parte de la Data Science Blogathon.

Guía práctica: Creando tu primer clasificador de enfermedades con Monk

Esta sección te guiará a través del proceso paso a paso de construir tu modelo Monk para la clasificación de enfermedades de las plantas. Ya seas nuevo en el aprendizaje automático o un científico de datos experimentado, sigue estas instrucciones para comenzar tu viaje de clasificación de enfermedades de las plantas.

Paso 1: Recopilación de datos

En este primer paso, recopilaremos el conjunto de datos necesario para nuestro proyecto de clasificación de enfermedades de las plantas. Sigue estos pasos para recopilar los datos:

El fantástico equipo de Plant Village recopiló el conjunto de datos

1. Cargar el token de API de Kaggle:

Utiliza el siguiente código para cargar tu token de API de Kaggle. Este token es necesario para descargar conjuntos de datos de Kaggle.

from google.colab import filesfiles.upload()

2. Instalar el paquete de Python de Kaggle:

Debes instalar el paquete de Python de Kaggle para interactuar con Kaggle desde tu entorno Colab. Ejecuta el siguiente comando:

!pip install kaggle

3. Configurar el directorio de configuración de Kaggle:

Establece el directorio de configuración de Kaggle en “/content” utilizando el siguiente código:

import osos.environ['KAGGLE_CONFIG_DIR'] = '/content'

4. Establecer permisos apropiados:

Asegúrate de que el archivo de token de API de Kaggle tenga los permisos correctos ejecutando:

!chmod 600 /content/kaggle.json

5. Descargar el conjunto de datos:

Utiliza la API de Kaggle para descargar el conjunto de datos de enfermedades de las plantas ejecutando este comando:

!kaggle datasets download -d "prashantmalge/plant-disease"

6. Descomprimir el conjunto de datos:

Finalmente, descomprime el conjunto de datos descargado utilizando el siguiente comando:

!unzip plant-disease.zip

Esto hará que el conjunto de datos esté disponible en tu entorno Colab para su procesamiento y entrenamiento adicionales. Ajusta el nombre y las rutas del conjunto de datos según sea necesario para tu proyecto específico.

Paso 2: Configuración de Monk

Primero, debes configurar Monk en tu máquina local o entorno en la nube. Sigue estos pasos para poner en marcha Monk:

1. Clonar el repositorio de Monk:

# Clonar el repositorio de Monk!git clone https://github.com/Tessellate-Imaging/monk_v1.git# Agregar el repositorio de Monk al path de Pythonimport syssys.path.append("./monk_v1/monk")# Instalar cualquier paquete o dependencia requeridos si es necesario# Descomenta y añade tu comando de instalación aquí# !pip install -r /kaggle/working/monk_v1/installation/requirements_kaggle.txt

2. Instalar Monk usando pip:

!pip install -U monk-colab

Paso 3: Crear un Experimento

Ahora, creemos un experimento en Monk. Un experimento es un entorno estructurado en el que defines los parámetros y configuraciones para entrenar tu clasificador de enfermedades. Aquí tienes un fragmento de código para que empieces:

from pytorch_prototype import prototype# Crear un experimentoptf = prototype(verbose=1)ptf.Prototype("planta_enfermedad", "exp1")

En este código, hemos nombrado nuestro experimento “planta_enfermedad” con la etiqueta “exp1”. Puedes ajustar los nombres según tu proyecto.

Paso 4: Carga de Datos y Preprocesamiento

Carga tu conjunto de datos y aplica transformaciones de datos para el preprocesamiento. Monk proporciona funciones convenientes para cargar datos y utilizar transformaciones. Aquí tienes un ejemplo:

# Cargar el conjunto de datos y definir transformacionesptf.Default(dataset_path=["./dataset/train", "./dataset/val"],             model_name="resnet18", freeze_base_network=True, num_epochs=5)

En este fragmento, especificamos la ruta del conjunto de datos y la arquitectura del modelo (ResNet-18) y congelamos los pesos de la red base.

Paso 5: Búsqueda Rápida de Modelos

Elige una arquitectura de modelo que se adapte a tus necesidades e inicia el proceso de entrenamiento. Monk admite varios modelos pre-entrenados y puedes ajustarlos según sea necesario. Así es cómo puedes hacerlo:

# Análisis - 1# Nombre del Proyecto de Análisisanalysis_name = "Model_Finder";# Modelos a analizar# Primer elemento de la lista - Nombre del Modelo# Segundo elemento de la lista - Valor booleano para congelar o no la red base# Tercer elemento de la lista - Valor booleano para usar el modelo pre-entrenado como punto de partida o no.models = [["resnet34", True, True], ["resnet50", False, True],           ["densenet121", False, True], ["densenet169", True, True], ["densenet201", True, True]];  # Número de épocas para cada experimentoepochs=5;# Porcentaje del conjunto de datos original a utilizar para experimentospercent_data=10;# "keep_all" - Mantener todos los subexperimentos creados# "keep_none" - Eliminar todos los subexperimentos creadosptf.Analyse_Models(analysis_name, models, percent_data, num_epochs=epochs, state="keep_none");

Nombre del Proyecto de Análisis: analysis_name es una variable que almacena el nombre del proyecto de análisis. En este caso, se establece como “Model_Finder”.
Modelos a Analizar: La lista de modelos especifica los modelos que deseas analizar. Cada modelo se representa como una lista con tres elementos:
Número de Épocas: el número de épocas que deseas ejecutar cada experimento. En este caso, se establece en 5.
Porcentaje del Conjunto de Datos Original: percent_data especifica el porcentaje del conjunto de datos original a utilizar para experimentación. Se establece en 10%, lo que significa que solo se utilizará el 10% del conjunto de datos.
Estado: El parámetro state determina si mantener o eliminar los subexperimentos. Cuando se establece en “keep_none”, no se mantendrán los subexperimentos y solo se conservarán los resultados finales.
Analyse_Models: Finalmente, se llama a la función ptf.Analyse_Models() con los parámetros especificados para realizar el análisis del modelo. Ejecutará experimentos para cada modelo y registrará los resultados.

Este código es útil para probar rápidamente varios modelos con diferentes configuraciones para encontrar el modelo de mejor rendimiento para tu tarea. Seleccionar una arquitectura de modelo adecuada es un paso estándar en proyectos de aprendizaje automático y aprendizaje profundo.

Salida:

Paso 6: Actualizar el Modelo

## Actualizar la arquitectura del modeloptf.update_model_name("densenet121");ptf.update_freeze_base_network(True);ptf.update_use_pretrained(True);ptf.Reload();

Actualizar el Nombre del Modelo: ptf.update_model_name(“densenet121”) actualiza la arquitectura del modelo a “densenet121”. Esto significa que estás cambiando del modelo utilizado anteriormente a DenseNet-121.
Actualizar Congelar la Red Base: ptf.update_freeze_base_network(True) establece el indicador para congelar la red base en “True”. Congelar la red base significa que las capas pre-entrenadas del modelo no se actualizarán durante el entrenamiento. Permanecerán fijas y solo se entrenarán las capas adicionales (si las hay). Esto puede ser útil al utilizar modelos pre-entrenados para el aprendizaje por transferencia.
Actualizar Usar Pre-entrenado: ptf.update_use_pretrained(True) establece el indicador para usar pesos pre-entrenados en “True”. Esto indica que deseas inicializar el modelo con pesos pre-entrenados. El uso de pesos pre-entrenados como punto de partida para el aprendizaje por transferencia es común, especialmente cuando cambias a una nueva arquitectura de modelo como DenseNet-121.
Recargar: ptf.Reload() recarga el modelo con las configuraciones actualizadas. Después de cambiar la arquitectura del modelo y sus ajustes, es esencial recargar el modelo para aplicar estos cambios.

En resumen, este código cambia la arquitectura del modelo a DenseNet-121, congela la red base y utiliza pesos pre-entrenados. Estos cambios se aplican al modelo al recargarlo.

Salida:

Paso 7: Encontrar el tamaño de lote correcto

#Análisis - 2# Nombre del proyecto de análisisanalysis_name = "Batch_Size_Finder";# Tamaños de lotes a explorarbatch_sizes = [4, 8, 16, 32];# Número de épocas para cada experimento    epochs = 10;# Porcentaje del conjunto de datos original para experimentarpercent_data = 10;# "keep_all" - Mantener todos los subexperimentos creados# "keep_non" - Eliminar todos los subexperimentos creados   ptf.Analyse_Batch_Sizes(analysis_name, batch_sizes, percent_data,                         num_epochs=epochs, state="keep_none");

Nombre del análisis: analysis_name = “Batch_Size_Finder” define el nombre de su análisis, que en este caso es “Batch_Size_Finder”. Este nombre le ayuda a identificar el propósito de este análisis.
Tamaños de lotes para explorar: batch_sizes = [4, 8, 16, 32] enumera los diferentes tamaños de lotes que desea explorar durante el análisis. En este ejemplo, se consideran los tamaños de lote 4, 8, 16 y 32.
Número de épocas: epochs = 10 especifica el número de épocas de entrenamiento para cada experimento durante el análisis. Cada experimento se ejecutará durante diez épocas para evaluar el rendimiento del modelo con diferentes tamaños de lote.
Porcentaje del conjunto de datos original: percent_data = 10 define el porcentaje del conjunto de datos original que desea utilizar para experimentar. En este caso, se utiliza el 10% del conjunto de datos.
Estado: state = “keep_none” especifica el estado de los subexperimentos creados durante el análisis. En este caso, “keep_none” significa que no desea conservar los subexperimentos creados durante este análisis. Se eliminarán después de que se complete el estudio.
Analizar tamaños de lotes: ptf.Analyse_Batch_Sizes(analysis_name, batch_sizes, percent_data, num_epochs=epochs, state=”keep_none”) inicia el análisis del tamaño de lote. Esta función ejecutará experimentos con diferentes tamaños de lotes (4, 8, 16 y 32) para evaluar su impacto en el rendimiento del modelo.

Este análisis tiene como objetivo determinar el tamaño de lote que produce el mejor rendimiento de entrenamiento y validación para su modelo de aprendizaje profundo. Diferentes tamaños de lote pueden afectar la velocidad de entrenamiento y la convergencia; este análisis le ayuda a encontrar un valor óptimo.

Salida:

Paso 8: Actualizar el tamaño de lote

## Actualizar el tamaño de loteptf.update_batch_size(8);ptf.Reload();

Actualizar el tamaño de lote: ptf.update_batch_size(8) actualiza el tamaño de lote de su modelo a 8. Esto significa que su modelo procesará los datos en lotes de tamaño ocho muestras durante el entrenamiento. El tamaño de lote es un hiperparámetro que puede influir en la velocidad de entrenamiento, el uso de memoria y la convergencia de su modelo.
Recargar: ptf.Reload() vuelve a cargar el modelo con el tamaño de lote actualizado. Esto es necesario porque cambiar el tamaño de lote puede afectar los requisitos de memoria de su modelo y volver a cargar asegura que el modelo esté configurado correctamente con el nuevo tamaño de lote.

Configurando el tamaño de lote en 8 significa que su modelo debe procesar los datos en 8 muestras por lote durante el entrenamiento. Este valor se determinó a partir de su análisis de tamaño de lote (como se muestra en el fragmento de código anterior) para encontrar un tamaño de lote óptimo para su tarea específica de aprendizaje profundo.

Salida:

Paso 9: Encontrar la dimensión de entrada correcta

#Análisis - 3# Nombre del proyecto de análisisanalysis_name = "Input_Size_Finder";# Tamaños de entrada para explorarinput_sizes = [224, 256, 512];# Número de épocas para cada experimento    epochs=5;# Porcentaje del conjunto de datos original para experimentarpercent_data=10;# "keep_all" - Mantener todos los subexperimentos creados# "keep_non" - Eliminar todos los subexperimentos creados   ptf.Analyse_Input_Sizes(analysis_name, input_sizes, percent_data,                         num_epochs=epochs, state="keep_none");

Nombre del Proyecto de Análisis: analysis_name = “Input_Size_Finder” define un nombre para este proyecto de análisis utilizado para organizar y etiquetar los experimentos relacionados con el tamaño de entrada.
Tamaños de Entrada a Explorar: input_sizes = [224, 256, 512] especifica una lista de tamaños de entrada (dimensiones de las imágenes) que deseas explorar. Estás probando tres tamaños de entrada diferentes: 224×224, 256×256 y 512×512 píxeles.
Número de Épocas: epochs = cinco establece el número de épocas de entrenamiento para cada experimento. En este caso, entrenas el modelo durante cinco épocas para cada tamaño de entrada.
Porcentaje del Conjunto de Datos Original: percent_data = 10 especifica el porcentaje del conjunto de datos original que se utilizará para experimentación. Utilizar una porción más pequeña del conjunto de datos puede acelerar el análisis al mismo tiempo que proporciona información sobre cómo los diferentes tamaños de entrada afectan el rendimiento del modelo.
Estado: state=“keep_none” indica que solo quieres mantener el experimento de mejor rendimiento y descartar los demás. Esto es útil para identificar de manera eficiente el tamaño de entrada óptimo sin llenar tu espacio de trabajo con múltiples experimentos.

Este análisis te permite determinar qué tamaño de entrada funciona mejor para tu tarea específica de aprendizaje profundo. Diferentes tamaños de entrada pueden afectar el rendimiento del modelo y la velocidad de entrenamiento, por lo que encontrar el equilibrio adecuado para tu proyecto es esencial.

Salida:

Paso 10: Actualizar el Tamaño de Entrada

## Actualizar Tamaño de Entrada
ptf.update_input_size(224);
ptf.Reload();

Actualizar el Tamaño de Entrada: ptf.update_input_size(224) establece el tamaño de entrada de tu modelo en 224×224 píxeles. Esto significa que tu modelo esperará que las imágenes de entrada tengan dimensiones de 224 píxeles de ancho y 224 píxeles de alto. Cambiar el tamaño de entrada puede afectar significativamente el rendimiento y el tiempo de entrenamiento de tu modelo.
Recargar: ptf.Reload() recarga el modelo con el tamaño de entrada actualizado. Este paso es necesario porque cambiar el tamaño de entrada requiere modificaciones en la arquitectura del modelo. La recarga asegura que el modelo esté configurado correctamente con el nuevo tamaño de entrada.

Al establecer el tamaño de entrada en 224×224 píxeles, has preparado eficazmente tu modelo para aceptar imágenes de este tamaño durante el entrenamiento e inferencia. La elección del tamaño de entrada debe coincidir con tu conjunto de datos y requisitos de tarea, y a menudo es un hiperparámetro crítico para ajustar para obtener resultados óptimos.

Salida:

Paso 11: Descubrir la Tasa de Aprendizaje Inicial Correcta

#Análisis - 4# Nombre del Proyecto de Análisis
analysis_name = "Learning_Rate_Finder"
# Tasas de aprendizaje a explorar
lrs = [0.01, 0.005, 0.001, 0.0001]
# Número de épocas para cada experimento a ejecutar
epochs = 5
# Porcentaje del conjunto de datos original a usar para experimentación
percent_data = 10
# "keep_all" - Mantener todos los subexperimentos creados
# "keep_none" - Eliminar todos los subexperimentos creados
ptf.Analyse_Learning_Rates(analysis_name, lrs, percent_data, num_epochs=epochs, state="keep_none");

Nombre del Proyecto de Análisis: analysis_name = “Learning_Rate_Finder” establece el nombre de tu proyecto de análisis de tasa de aprendizaje. Utilizarás este nombre para organizar los resultados de tus experimentos.
Tasas de Aprendizaje a Explorar: lrs = [0.01, 0.005, 0.001, 0.0001] especifica una lista de tasas de aprendizaje a explorar durante el análisis. La tasa de aprendizaje es un hiperparámetro crucial en el entrenamiento de redes neuronales profundas, y encontrar la tasa de aprendizaje correcta puede tener un impacto significativo en el éxito del entrenamiento.
Número de Épocas: epochs = 5 determina el número de épocas (iteraciones de entrenamiento) que se ejecutarán para cada experimento de tasa de aprendizaje. Esto ayuda a evaluar qué tan rápido el modelo converge con diferentes tasas de aprendizaje.
Porcentaje del Conjunto de Datos Original: percent_data = 10 define el porcentaje de tu conjunto de datos original utilizado para la experimentación. Utilizar un subconjunto más pequeño de los datos puede acelerar el proceso de análisis al mismo tiempo que proporciona información.
“keep_all” o “keep_none”: state=“keep_none” especifica si mantener o eliminar todos los subexperimentos creados durante el análisis de la tasa de aprendizaje. En este caso, “keep_none” significa que no se guardarán los subexperimentos, probablemente porque el objetivo principal es identificar la mejor tasa de aprendizaje en lugar de conservar los resultados intermedios.

Después de ejecutar este código, el análisis explorará las tasas de aprendizaje especificadas, entrenará el modelo durante algunas épocas con cada tasa de aprendizaje, y recopilará métricas de rendimiento. Esta información te ayudará a elegir la tasa de aprendizaje más adecuada para tu modelo y conjunto de datos.

Resultado:

Paso 12: Actualizar tasa de aprendizaje

## Actualizar tasa de aprendizajeptf.actualizar_tasa_aprendizaje(0.01);ptf.Recargar();

Actualizar tasa de aprendizaje: ptf.actualizar_tasa_aprendizaje(0.01) actualiza la tasa de aprendizaje a 0.01. La tasa de aprendizaje es un hiperparámetro que controla el tamaño del paso durante la optimización. Determina cuánto se actualizan los parámetros del modelo en cada iteración de entrenamiento.
Recargar: ptf.Recargar() recarga el modelo con la tasa de aprendizaje actualizada. Recargar el modelo asegura que los cambios en la tasa de aprendizaje surtan efecto durante las sesiones de entrenamiento posteriores.

Al establecer la tasa de aprendizaje en 0.01, puedes especificar una nueva tasa de aprendizaje para tu modelo. Ajustar la tasa de aprendizaje es común en la afinación de modelos de aprendizaje profundo para mejorar la estabilidad y convergencia del entrenamiento.

Resultado:

Paso 13: Búsqueda del optimizador

# Análisis - 5# Nombre del proyecto de análisisnombre_analisis = "Buscador_Optimizador";# Optimizadores a exploraroptimizadores = ["sgd", "adam", "adamax", "rmsprop"];   # Nombre del modelo, tasa de aprendizaje# Número de épocas para cada experimento a ejecutarepocas = 5;# Porcentaje del conjunto de datos original a utilizar en la experimentaciónporcentaje_datos = 10;# "keep_all" - Mantener todos los subexperimentos creados# "keep_non" - Eliminar todos los subexperimentos creadosptf.Analizar_Optimizadores(nombre_analisis, optimizadores, porcentaje_datos,                        num_epochs=epocas, state="keep_none");

Nombre del proyecto de análisis: nombre_analisis = “Buscador_Optimizador”; define el nombre del proyecto de análisis como “Buscador_Optimizador”. Este proyecto se centrará en encontrar el optimizador óptimo para tu modelo.
Optimizadores a explorar: optimizadores es una lista que contiene los nombres de los optimizadores a explorar. Los optimizadores incluyen “sgd”, “adam”, “adamax” y “rmsprop”. Cada optimizador tiene sus propias técnicas de optimización e hiperparámetros.
Número de épocas: épocas = 5; especifica el número de épocas para cada experimento ejecutado durante el análisis. Una época es un pase completo por todo el conjunto de datos de entrenamiento.
Porcentaje del conjunto de datos original: porcentaje_datos = 10; determina el porcentaje del conjunto de datos original que se utilizará para la experimentación. En este caso, se utilizará el 10% del conjunto de datos.
Analizar_Optimizadores: ptf.Analizar_Optimizadores(nombre_analisis, optimizadores, porcentaje_datos, num_epochs=epocas, state=”keep_none”); inicia el análisis de diferentes optimizadores. Se ejecutarán experimentos utilizando cada optimizador enumerado en la lista de optimizadores y se registrarán los resultados.

Al analizar diferentes optimizadores, puedes identificar cuál funciona mejor para tu conjunto de datos y modelo de aprendizaje profundo. La elección del optimizador puede tener un impacto significativo en el entrenamiento y rendimiento de tu red neuronal.

Resultado:

Paso 14: Actualizar optimizador

## Actualizar nombre del optimizadorptf.optimizador_adamax(0.001);ptf.Recargar();

Actualizar nombre del optimizador: ptf.optimizador_adamax(0.001); establece el optimizador como “Adamax” con una tasa de aprendizaje de 0.001.
Recargar modelo: ptf.Recargar(); recarga el modelo con la nueva configuración del optimizador.

Estás cambiando el algoritmo de optimización utilizado durante el entrenamiento mediante la actualización del optimizador a “Adamax” con una tasa de aprendizaje específica. Diferentes optimizadores pueden converger a diferentes velocidades, lo que conduce a variaciones en el proceso de entrenamiento y rendimiento final del modelo. Es común experimentar con otros optimizadores y tasas de aprendizaje para encontrar la mejor combinación para tu tarea específica de aprendizaje profundo.

Paso 15: Establecer estado intermedio: Guardar en Falso

ptf.update_save_intermediate_models(False);

ptf: Se refiere al objeto de prototipo de PyTorch que has creado.
update_save_intermediate_models(False): Esta función actualiza la configuración para guardar modelos intermedios durante el entrenamiento. Desactivas la opción de guardar modelos intermedios pasando False como argumento.

Los modelos intermedios son instantáneas de los parámetros de tu modelo guardados en intervalos específicos durante el entrenamiento. Pueden ayudar a reanudar el entrenamiento desde un punto de control específico o analizar el rendimiento del modelo en diversas etapas del entrenamiento.

Establecer esta opción en False significa que tu código no guardará modelos intermedios durante el proceso de entrenamiento, lo cual puede ser beneficioso si deseas conservar espacio en disco o no necesitas realizar un seguimiento de los puntos de control intermedios.

A continuación, creamos un nuevo experimento usando ‘copy_experiment’ y reanudamos el entrenamiento para lograr mejorar aún más.

ptf = prototype(verbose=1); ptf.Prototype("enfermedad_plantas", "exp2", copy_from=["enfermedad_plantas", "exp1"]);

ptf = prototype(verbose=1);: Creas un nuevo objeto de prototipo llamado ptf con el modo verboso habilitado. Este objeto te permite definir y administrar experimentos de aprendizaje automático.
ptf.Prototype(“enfermedad_plantas”, “exp2”, copy_from=[“enfermedad_plantas”, “exp1”]);: Esta línea especifica los detalles del nuevo experimento:

Al crear un nuevo experimento con la misma configuración que uno existente, puedes iterar rápidamente en tus experimentos mientras mantienes la consistencia en las configuraciones y el seguimiento del progreso.

Resumen de la configuración del experimento:

ptf.Summary()

Salida:

Paso 16: Comparar

Monk proporciona una función “Comparar” simplificada que recopila estadísticas, visualiza resultados y ayuda a los usuarios a decidir qué arquitecturas de modelos e hiperparámetros son más efectivos. Este paso ayuda en el proceso iterativo de ajuste fino de modelos y mejora progresiva de su rendimiento, y finalmente guía la selección de las configuraciones de modelo que mejor funcionen para su implementación.

from compare_prototype import comparectf = compare(verbose=1);ctf.Comparison("enfermedad_plantas");ctf.Add_Experiment("enfermedad_plantas", "exp1");ctf.Add_Experiment("enfermedad_plantas", "exp2");

Estos fragmentos de código demuestran el uso del módulo “compare_prototype” de Monk. Primero, importa la función necesaria “compare”. Luego, inicializa un objeto de comparación “ctf” con verbosity establecido en 1 para informes. La comparación se llama “enfermedad_plantas” mediante ctf.Comparison.

A continuación, se agregan a la comparación dos experimentos, “exp1” y “exp2”, realizados dentro del proyecto “enfermedad_plantas” mediante ctf.Add_Experiment. Esto permite a los usuarios analizar y comparar los resultados, métricas y rendimiento de estos dos experimentos para tomar decisiones informadas sobre la selección y el ajuste fino del modelo.

Paso 17: Inferencia

La inferencia en Monk utiliza un modelo entrenado para predecir nuevos datos no vistos. Te permite utilizar tu modelo entrenado para aplicaciones del mundo real, como clasificar imágenes, reconocer objetos o tomar decisiones basadas en la salida del modelo. La inferencia normalmente implica cargar un modelo entrenado, proporcionar datos de entrada y obtener predicciones o clasificaciones del modelo. Monk ofrece herramientas y funciones para agilizar el proceso de inferencia y simplificar la implementación de modelos de aprendizaje automático para uso práctico.

import numpy as npimport PIL.Image as Imageimport requeststest_url = "https://gardenerspath.com/wp-content/uploads/2019/08/            Frogeye-spots-Botryosphaeria-obtusa-on-apple-leaf-FB.jpg"# URL de la imagen a descargar se define como image_urlr = requests.get(test_url) # crea un objeto de respuesta HTTPwith open('test.jpg','wb') as f:     f.write(r.content)test = Image.open('./test.jpg')test

Salida:

ptf.Prototype("enfermedad_plantas", "exp2", eval_infer=True);

ptf.Prototype(“enfermedad_plantas”, “exp2”, eval_infer=True);: Esta línea configura un nuevo experimento llamado “exp2” bajo el proyecto “enfermedad_plantas” utilizando la función Prototype de Monk. También habilita el modo de evaluación e inferencia (eval_infer=True), lo que indica que este experimento se utilizará para hacer predicciones sobre nuevos datos.

Salida :

Detalles del modelo: Después de inicializar el experimento, el código carga un modelo pre-entrenado. En este caso, está cargando un modelo desde el directorio “workspace/plant_disease/exp2/output/models/final”. Este modelo se utilizará para realizar inferencias.
Detalles del experimento: Esta sección proporciona información sobre el experimento, incluyendo el nombre del proyecto (“plant_disease”), el nombre del experimento (“exp2”) y el directorio donde se encuentra almacenado el experimento.

Paso 18: Predicción

img_name = "test.jpg";predictions = ptf.Infer(img_name=img_name, return_raw=True);print(predictions)

img_name = “test.jpg”;: Esta línea especifica el nombre del archivo de imagen (“test.jpg”) en el que quieres realizar la inferencia. Puedes reemplazar “test.jpg” con la ruta de la imagen que deseas analizar.
Predictions = ptf.Infer(img_name=img_name, return_raw=True);: Esta línea de código llama a la función “Infer” proporcionada por el experimento de Monk (ptf) para realizar predicciones en la imagen especificada. Esta función recibe como entrada el nombre del archivo de imagen y solicita puntuaciones de predicción sin procesar estableciendo “return_raw=True”. Esto significa que devolverá las puntuaciones numéricas sin procesar para cada clase.
print(predictions): Por último, el código imprime las predicciones. Estas predicciones suelen incluir información como la clase predicha y las puntuaciones sin procesar asociadas a cada clase.

Este código te permite analizar la imagen especificada utilizando el modelo entrenado y obtener predicciones para varias clases y sus puntuaciones de confianza. La salida impresa proporcionará información sobre la predicción del modelo para la imagen dada.

import csvdef read_labels():    mydict = {}    with open('./dataset/labels.csv', mode='r') as infile:        reader = csv.reader(infile)        with open('labels_new.csv', mode='w') as outfile:            writer = csv.writer(outfile)            mydict = {rows[0]:rows[1] for rows in reader}    return mydictdef predict_label(predictions):    pred_class = predictions['predicted_class']    label_dict = read_labels()    out_label = label_dict[pred_class]    return out_labelprint("Clase predicha para la imagen de prueba es: {}".format(predict_label(predictions)))

Función read_labels(): Esta función lee información de etiquetas del archivo “labels.csv”. Abre el archivo CSV, lee su contenido y crea un diccionario (mydict) donde las claves son las IDs de clase y los valores son las etiquetas correspondientes. Luego, escribe esta información de etiquetas en un nuevo archivo CSV llamado “labels_new.csv”.
Función predict_label(predictions): Esta función toma las predicciones obtenidas de la inferencia anterior como entrada. Extrae la ID de clase predicha de las predicciones y utiliza el diccionario de etiquetas creado anteriormente para encontrar la etiqueta correspondiente. Luego, devuelve esa etiqueta como out_label.
Imprimiendo el resultado: El código llama a la función predict_label(predictions) para obtener la etiqueta asociada con la clase predicha e imprime esto como “Clase predicha para la imagen de prueba es”.

En resumen, este código te ayuda a traducir la ID de clase numérica predicha por el modelo en una etiqueta legible para los humanos, lo que facilita la comprensión de la salida del modelo.

Salida: Clase predicha para la imagen de prueba es: Apple___Black_rot

Técnicas avanzadas para la clasificación de enfermedades de plantas

Exploraremos técnicas y estrategias avanzadas para llevar tu proyecto de clasificación de enfermedades de plantas al siguiente nivel.

1. Transfer Learning con datos personalizados

Aunque usar modelos pre-entrenados es un excelente punto de partida, puedes mejorar aún más la precisión de tu clasificador ajustándolo con datos personalizados. Recopila más imágenes específicas de las especies de plantas y enfermedades que deseas detectar. Puedes adaptar un modelo pre-entrenado a tu conjunto de datos ajustándolo para reconocer patrones y síntomas únicos.

# Ajuste fino de un modelo pre-entrenado con datos personalizadosptf.update_model_name("resnet50")ptf.update_freeze_base_network(False)  # Desbloquear la red base para ajuste finoptf.update_use_pretrained(True)ptf.Reload()ptf.Train()

2. Aumento de datos

El aumento de datos es una técnica poderosa para aumentar la diversidad de tu conjunto de datos de entrenamiento artificialmente. Al aplicar transformaciones aleatorias como rotación, recorte y ajustes de brillo a tus imágenes, puedes mejorar la capacidad de generalización de tu modelo. Monk proporciona funciones convenientes para el aumento de datos:

# Aplica transformaciones de aumento de datos
ptf.apply_random_rotation(train=True, val=True)
ptf.apply_random_crop(scale=[0.8, 1.0], ratio=[0.8, 1.2], train=True)
ptf.apply_random_brightness(train=True)

3. Manejo del desequilibrio de clases

En escenarios del mundo real, es posible que te encuentres con desequilibrio de clases, donde algunas enfermedades de las plantas son más prevalentes que otras. Para abordar esto, considera técnicas como el sobremuestreo de clases minoritarias o la aplicación de pesos de clase durante el entrenamiento. Monk ofrece funciones de pérdida ponderada de clase para manejar conjuntos de datos desequilibrados.

# Usa una función de pérdida ponderada por clase
ptf.loss_weighted_softmax_crossentropy(class_weights)

4. Ensemble Learning

El aprendizaje en conjunto implica combinar predicciones de múltiples modelos para mejorar la precisión y robustez. Puedes crear un conjunto de diferentes arquitecturas o variaciones del mismo modelo para obtener mejores resultados. Monk admite el aprendizaje en conjunto, lo que te permite experimentar con diferentes combinaciones de modelos.

# Crea un conjunto de modelos
ensemble = ptf.create_ensemble(models)
ensemble.Train()

5. Ajuste de hiperparámetros

El ajuste fino de los hiperparámetros es crucial para optimizar el rendimiento de tu modelo. Monk proporciona herramientas para el ajuste de hiperparámetros, lo que te permite explorar diferentes tasas de aprendizaje, tamaños de lote y algoritmos de optimización.

# Ajuste de hiperparámetros - Tasa de aprendizaje, tamaño de lote, optimizador
ptf.Analyse_Learning_Rates("LR_Finder", lrs, percent_data=10, num_epochs=5)
ptf.Analyse_Batch_Sizes("Batch_Size_Finder", batch_sizes, percent_data=10, num_epochs=5)
ptf.Analyse_Optimizers("Optimizer_Finder", optimizers, percent_data=10, num_epochs=5)

6. Interpretabilidad del modelo

Comprender por qué un modelo hace predicciones específicas es esencial, especialmente en aplicaciones críticas como la clasificación de enfermedades. Monk proporciona herramientas de interpretación como Grad-CAM (Mapeo de Activación de Clase Ponderada por Gradiente) para visualizar qué regiones de una imagen son más influyentes para una predicción.

# Visualiza las predicciones del modelo con Grad-CAM
heatmap = ptf.Visualize_With_GradCAM(image_path, target_layer)

Conclusion

En esta guía integral, hemos explorado el fascinante mundo de la clasificación de enfermedades de las plantas utilizando Monk. Hemos cubierto todo, desde la configuración de tus experimentos hasta el ajuste fino de los modelos y la comprensión de aplicaciones del mundo real. A medida que concluimos, repasemos los puntos clave y discutamos las emocionantes direcciones futuras de esta tecnología.

Puntos clave:

Monk Simplifica el Aprendizaje Profundo: Monk ofrece una interfaz amigable e intuitiva para construir, entrenar y desplegar modelos de aprendizaje profundo. Su enfoque modular permite incluso a los principiantes sumergirse en la visión por computadora sin esfuerzo.
Detección Precoz de Enfermedades: Las enfermedades de las plantas pueden devastar los cultivos y amenazar la seguridad alimentaria. Los modelos impulsados por Monk permiten la detección temprana de enfermedades, ayudando a los agricultores a proteger proactivamente sus cultivos.
Agricultura de Precisión: Monk contribuye a la agricultura de precisión optimizando el uso de recursos, reduciendo los insumos químicos y aumentando los rendimientos de los cultivos. Los agricultores pueden lograr una mayor rentabilidad y sostenibilidad ambiental.
Impacto en el Mundo Real: Las aplicaciones de Monk se extienden más allá de la agricultura a la investigación, la conservación y la ciencia ciudadana. Empodera a individuos y organizaciones para impactar positivamente la salud de las plantas y los ecosistemas.

Recursos para Aprender Más

Para adentrarte más en la clasificación de enfermedades de las plantas con Monk, aquí tienes algunos recursos valiosos:

Documentación oficial de Monk -> Docs
Conjunto de datos Plant Village -> Docs
Instalación de Monk -> Docs
Modo Rápido PyTorch -> Docs
Modo Rápido Keras -> Docs
Modo Rápido Gluon -> Docs
Buscador de Modelos -> Docs

Monk sigue estando a la vanguardia en soluciones de clasificación de enfermedades vegetales. Su interfaz fácil de usar y sus poderosas capacidades permiten a individuos y organizaciones contribuir al bienestar de los ecosistemas del planeta y el suministro de alimentos a nivel mundial.

Preguntas frecuentes

Los medios mostrados en este artículo no son propiedad de Analytics Vidhya y se utilizan bajo la discreción del autor.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!

agriculture with AIAI in Agricultureclassificationclassification using Monks

Was this article helpful?

93 out of 132 found this helpful