Transformadores de Visión en Agricultura | Innovación en la Cosecha

Transformadores de Visión en Agricultura | Innovación en Cosecha

Introducción

La agricultura siempre ha sido un pilar de la civilización humana, proporcionando sustento y medios de vida para miles de millones de personas en todo el mundo. A medida que avanza la tecnología, encontramos nuevas e innovadoras formas de mejorar las prácticas agrícolas. Uno de estos avances es el uso de Transformadores de Visión (ViTs) para clasificar las enfermedades de las hojas en los cultivos. En este blog, exploraremos cómo los transformadores de visión en la agricultura revolucionan al ofrecer una solución eficiente y precisa para identificar y mitigar las enfermedades de los cultivos.

La yuca, también conocida como mandioca o casava, es un cultivo versátil con diversos usos, desde proporcionar alimentos básicos hasta aplicaciones industriales. Su resistencia y capacidad de adaptación lo convierten en un cultivo esencial para regiones con condiciones de cultivo desafiantes. Sin embargo, las plantas de yuca son vulnerables a diversas enfermedades, siendo CMD y CBSD algunas de las más destructivas.

CMD es causada por un complejo de virus transmitidos por moscas blancas, lo que provoca síntomas graves de mosaico en las hojas de yuca. CBSD, por otro lado, es causada por dos virus relacionados y afecta principalmente las raíces de almacenamiento, volviéndolas no comestibles. Identificar estas enfermedades de forma temprana es crucial para prevenir daños generalizados en los cultivos y garantizar la seguridad alimentaria. Los Transformadores de Visión, una evolución de la arquitectura de los transformadores diseñada inicialmente para el procesamiento del lenguaje natural (PLN), han demostrado ser muy efectivos en el procesamiento de datos visuales. Estos modelos procesan imágenes como secuencias de parches, utilizando mecanismos de autoatención para capturar patrones y relaciones intrincadas en los datos. En el contexto de la clasificación de enfermedades de las hojas de yuca, los ViTs se entrenan para identificar CMD y CBSD mediante el análisis de imágenes de hojas de yuca infectadas.

Resultados del aprendizaje

Comprender los Transformadores de Visión y cómo se aplican a la agricultura, específicamente para la clasificación de enfermedades de las hojas.
Aprender sobre los conceptos fundamentales de la arquitectura de los transformadores, incluidos los mecanismos de autoatención y cómo se adaptan para el procesamiento de datos visuales.
Comprender el uso innovador de los Transformadores de Visión (ViTs) en la agricultura, específicamente para la detección temprana de enfermedades de las hojas de yuca.
Obtener información sobre las ventajas de los Transformadores de Visión, como la escalabilidad y el contexto global, así como los desafíos, incluidos los requisitos computacionales y la eficiencia de los datos.

Este artículo se publicó como parte del Data Science Blogathon.

El surgimiento de los Transformadores de Visión

La visión por computadora ha dado grandes avances en los últimos años, gracias al desarrollo de redes neuronales convolucionales (CNNs). Las CNNs han sido la arquitectura preferida para diversas tareas relacionadas con imágenes, desde la clasificación de imágenes hasta la detección de objetos. Sin embargo, los Transformadores de Visión han surgido como una fuerte alternativa, ofreciendo un enfoque novedoso para el procesamiento de información visual. Investigadores de Google Research presentaron los Transformadores de Visión en 2020 en un artículo innovador titulado “Una imagen vale 16×16 palabras: Transformadores para el reconocimiento de imágenes a gran escala”. Adaptaron la arquitectura de los transformadores, diseñada inicialmente para el procesamiento del lenguaje natural (PLN), al campo de la visión por computadora. Esta adaptación ha abierto nuevas posibilidades y desafíos en el campo.

El uso de los ViTs ofrece varias ventajas en comparación con los métodos tradicionales, incluyendo:

Alta precisión: Los ViTs destacan en precisión, permitiendo la detección y diferenciación confiable de enfermedades de las hojas.
Eficiencia: Una vez entrenados, los ViTs pueden procesar imágenes rápidamente, lo que los hace adecuados para la detección en tiempo real de enfermedades en el campo.
Escalabilidad: Los ViTs pueden manejar conjuntos de datos de diferentes tamaños, lo que los hace adaptables a diferentes entornos agrícolas.
Generalización: Los ViTs pueden generalizar para diferentes variedades de yuca y tipos de enfermedades, reduciendo la necesidad de modelos específicos para cada escenario.

La arquitectura de los Transformadores: Una breve descripción

Antes de adentrarnos en los Transformadores de Visión, es esencial comprender los conceptos básicos de la arquitectura de los transformadores. Los transformadores, diseñados originalmente para el PLN, revolucionaron las tareas de procesamiento del lenguaje. Las características clave de los transformadores son los mecanismos de autoatención y la paralelización, que permiten una comprensión de contexto más completa y un entrenamiento más rápido.

En el corazón de los transformadores se encuentra el mecanismo de autoatención, que permite al modelo ponderar la importancia de diferentes elementos de entrada al realizar predicciones. Este mecanismo, combinado con capas de atención de múltiples cabezas, captura relaciones complejas en los datos.

Entonces, ¿cómo aplican los Transformadores de Visión esta arquitectura de transformador al campo de la visión por computadora? La idea fundamental detrás de los Transformadores de Visión es tratar una imagen como una secuencia de parches, al igual que las tareas de PLN tratan el texto como una secuencia de palabras. Las capas de transformador procesan cada parche en la imagen al incrustarlo en un vector.

Componentes Clave de un Vision Transformer

Embebidos de Parches: Divide una imagen en parches de tamaño fijo y no superpuestos, típicamente de 16×16 píxeles. Cada parche se incrusta linealmente en un vector de menor dimensión.
Codificaciones posicionales: Agrega codificaciones posicionales a los embebidos de parches para tener en cuenta la disposición espacial de los parches. Esto permite que el modelo aprenda las posiciones relativas de los parches dentro de la imagen.
Encoder Transformer: Los Vision Transformers consisten en múltiples capas de encoder transformer como los transformers de NLP. Cada capa realiza operaciones de autoatención y de avance hacia adelante en los embebidos de parches.
Cabeza de Clasificación: Al final de las capas del transformer, se agrega una cabeza de clasificación para tareas como la clasificación de imágenes. Toma los embebidos de salida y produce probabilidades de clase.

La introducción de Vision Transformers marca una desviación significativa de las CNN, que se basan en capas convolucionales para la extracción de características. Al tratar las imágenes como secuencias de parches, los Vision Transformers logran resultados de vanguardia en diversas tareas de visión por computadora, incluyendo la clasificación de imágenes, la detección de objetos e incluso el análisis de videos.

Implementación

Conjunto de Datos

El conjunto de datos de Enfermedades de la Hoja de Yuca consta de alrededor de 15,000 imágenes de alta resolución de hojas de yuca que muestran varias etapas y grados de síntomas de enfermedades. Cada imagen está meticulosamente etiquetada para indicar la enfermedad presente, lo que permite el aprendizaje automático supervisado y las tareas de clasificación de imágenes. Las enfermedades de la yuca presentan características distintivas, lo que lleva a su clasificación en varias categorías. Estas categorías incluyen la Plaga Bacteriana de la Yuca (CBB), la Enfermedad de Franjas Marrones de la Yuca (CBSD), la Motas Verdes de la Yuca (CGM) y la Enfermedad del Mosaico de la Yuca (CMD). Los investigadores y científicos de datos aprovechan este conjunto de datos para entrenar y evaluar modelos de aprendizaje automático, incluidas redes neuronales profundas como los Vision Transformers (ViTs).

Importación de las Bibliotecas Necesarias

import numpy as np
import pandas as pd
import tensorflow as tf
import tensorflow.keras.layers as L
import tensorflow_addons as tfa
import glob, random, os, warnings
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, classification_report
import seaborn as sns csv

Cargar el Conjunto de Datos

image_size = 224
batch_size = 16
n_classes = 5

train_path = '/kaggle/input/cassava-leaf-disease-classification/train_images'
test_path = '/kaggle/input/cassava-leaf-disease-classification/test_images'

df_train = pd.read_csv('/kaggle/input/cassava-leaf-disease-classification/train.csv', dtype = 'str')

test_images = glob.glob(test_path + '/*.jpg')
df_test = pd.DataFrame(test_images, columns = ['image_path'])

classes = {0 : "Plaga Bacteriana de la Yuca (CBB)",
           1 : "Enfermedad de Franjas Marrones de la Yuca (CBSD)",
           2 : "Motas Verdes de la Yuca (CGM)",
           3 : "Enfermedad del Mosaico de la Yuca (CMD)",
           4 : "Saludable"}#import csv

Aumento de Datos

def data_augment(image):
    p_spatial = tf.random.uniform([], 0, 1.0, dtype = tf.float32)
    p_rotate = tf.random.uniform([], 0, 1.0, dtype = tf.float32)
 
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_flip_up_down(image)
    
    if p_spatial > .75:
        image = tf.image.transpose(image)
        
    # Rotates
    if p_rotate > .75:
        image = tf.image.rot90(image, k = 3) # rotate 270º
    elif p_rotate > .5:
        image = tf.image.rot90(image, k = 2) # rotate 180º
    elif p_rotate > .25:
        image = tf.image.rot90(image, k = 1) # rotate 90º
        
    return image#import csv

Generador de Datos

datagen = tf.keras.preprocessing.image.ImageDataGenerator(samplewise_center = True,
                                                          samplewise_std_normalization = True,
                                                          validation_split = 0.2,
                                                          preprocessing_function = data_augment)

train_gen = datagen.flow_from_dataframe(dataframe = df_train,
                                        directory = train_path,
                                        x_col = 'image_id',
                                        y_col = 'label',
                                        subset = 'training',
                                        batch_size = batch_size,
                                        seed = 1,
                                        color_mode = 'rgb',
                                        shuffle = True,
                                        class_mode = 'categorical',
                                        target_size = (image_size, image_size))

valid_gen = datagen.flow_from_dataframe(dataframe = df_train,
                                        directory = train_path,
                                        x_col = 'image_id',
                                        y_col = 'label',
                                        subset = 'validation',
                                        batch_size = batch_size,
                                        seed = 1,
                                        color_mode = 'rgb',
                                        shuffle = False,
                                        class_mode = 'categorical',
                                        target_size = (image_size, image_size))

test_gen = datagen.flow_from_dataframe(dataframe = df_test,
                                       x_col = 'image_path',
                                       y_col = None,
                                       batch_size = batch_size,
                                       seed = 1,
                                       color_mode = 'rgb',
                                       shuffle = False,
                                       class_mode = None,
                                       target_size = (image_size, image_size))#import csv

images = [train_gen[0][0][i] for i in range(16)]
fig, axes = plt.subplots(3, 5, figsize = (10, 10))

axes = axes.flatten()

for img, ax in zip(images, axes):
    ax.imshow(img.reshape(image_size, image_size, 3))
    ax.axis('off')

plt.tight_layout()
plt.show()#import csv

Construcción del Modelo

learning_rate = 0.001
weight_decay = 0.0001
num_epochs = 1

patch_size = 7  # Tamaño de los parches extraídos de las imágenes de entrada
num_patches = (image_size // patch_size) ** 2
projection_dim = 64
num_heads = 4
transformer_units = [
    projection_dim * 2,
    projection_dim,
]  # Tamaño de las capas del transformador
transformer_layers = 8
mlp_head_units = [56, 28]  # Tamaño de las capas densas del clasificador final

def mlp(x, hidden_units, dropout_rate):
    for units in hidden_units:
        x = L.Dense(units, activation = tf.nn.gelu)(x)
        x = L.Dropout(dropout_rate)(x)
    return x

Creación de Parches

En nuestro proyecto de clasificación de enfermedades de hojas de yuca, utilizamos capas personalizadas para facilitar la extracción y codificación de parches de imagen. Estas capas especializadas son fundamentales para preparar nuestros datos para su procesamiento por el modelo Vision Transformer.

class Patches(L.Layer):
    def __init__(self, patch_size):
        super(Patches, self).__init__()
        self.patch_size = patch_size

    def call(self, images):
        batch_size = tf.shape(images)[0]
        patches = tf.image.extract_patches(
            images = images,
            sizes = [1, self.patch_size, self.patch_size, 1],
            strides = [1, self.patch_size, self.patch_size, 1],
            rates = [1, 1, 1, 1],
            padding = 'VALID',
        )
        patch_dims = patches.shape[-1]
        patches = tf.reshape(patches, [batch_size, -1, patch_dims])
        return patches
        
plt.figure(figsize=(4, 4))

x = train_gen.next()
image = x[0][0]

plt.imshow(image.astype('uint8'))
plt.axis('off')

resized_image = tf.image.resize(
    tf.convert_to_tensor([image]), size = (image_size, image_size)
)

patches = Patches(patch_size)(resized_image)
print(f'Tamaño de la imagen: {image_size} X {image_size}')
print(f'Tamaño del parche: {patch_size} X {patch_size}')
print(f'Parches por imagen: {patches.shape[1]}')
print(f'Elementos por parche: {patches.shape[-1]}')

n = int(np.sqrt(patches.shape[1]))
plt.figure(figsize=(4, 4))

for i, patch in enumerate(patches[0]):
    ax = plt.subplot(n, n, i + 1)
    patch_img = tf.reshape(patch, (patch_size, patch_size, 3))
    plt.imshow(patch_img.numpy().astype('uint8'))
    plt.axis('off')
    
class PatchEncoder(L.Layer):
    def __init__(self, num_patches, projection_dim):
        super(PatchEncoder, self).__init__()
        self.num_patches = num_patches
        self.projection = L.Dense(units = projection_dim)
        self.position_embedding = L.Embedding(
            input_dim = num_patches, output_dim = projection_dim
        )

    def call(self, patch):
        positions = tf.range(start = 0, limit = self.num_patches, delta = 1)
        encoded = self.projection(patch) + self.position_embedding(positions)
        return encoded#import csv

Capa de Parches (clase Patches(L.Layer)

La capa de Parches inicia nuestro pipeline de preprocesamiento de datos extrayendo parches de las imágenes de entrada. Estos parches representan regiones más pequeñas y no superpuestas de la imagen original. La capa opera en lotes de imágenes, extrayendo parches de un tamaño específico y remodelándolos para su posterior procesamiento. Este paso es esencial para permitir que el modelo se enfoque en detalles en la imagen a nivel de píxeles, lo que contribuye a su capacidad para capturar patrones intrincados.

Visualización de los Parches de Imagen

Después de extraer los parches, visualizamos su impacto en la imagen mostrando una imagen de muestra superpuesta con una rejilla que muestra los parches extraídos. Esta visualización ofrece información sobre cómo se divide la imagen en estos parches, destacando el tamaño del parche y el número de parches extraídos de cada imagen. Ayuda a comprender la etapa de preprocesamiento y prepara el escenario para el análisis posterior.

Capa de Codificación de Parches (clase PatchEncoder(L.Layer)

Una vez extraídos los parches, se someten a un procesamiento adicional a través de la capa PatchEncoder. Esta capa es fundamental para codificar la información contenida en cada parche. Consta de dos componentes clave: una proyección lineal que mejora las características del parche y una inserción de posición que agrega contexto espacial. Las representaciones de parches enriquecidos resultantes son fundamentales para el análisis y aprendizaje del Vision Transformer, lo que contribuye en última instancia a la eficacia del modelo en la clasificación precisa de enfermedades.

Las capas personalizadas, Patches y PatchEncoder, son fundamentales para nuestra tubería de preprocesamiento de datos para la clasificación de enfermedades de las hojas de yuca. Permiten que el modelo se centre en los parches de imagen, mejorando su capacidad para discernir patrones y características pertinentes esenciales para una clasificación precisa de enfermedades. Este proceso fortalece significativamente el rendimiento general de nuestro modelo Vision Transformer.

def vision_transformer():
    inputs = L.Input(shape = (image_size, image_size, 3))
    
    # Crear parches.
    patches = Patches(patch_size)(inputs)
    
    # Codificar parches.
    encoded_patches = PatchEncoder(num_patches, projection_dim)(patches)

    # Crear múltiples capas del bloque Transformer.
    for _ in range(transformer_layers):
        
        # Normalización de capa 1.
        x1 = L.LayerNormalization(epsilon = 1e-6)(encoded_patches)
        
        # Crear una capa de atención multi-cabeza.
        attention_output = L.MultiHeadAttention(
            num_heads = num_heads, key_dim = projection_dim, dropout = 0.1
        )(x1, x1)
        
        # Conexión de salto 1.
        x2 = L.Add()([attention_output, encoded_patches])
        
        # Normalización de capa 2.
        x3 = L.LayerNormalization(epsilon = 1e-6)(x2)
        
        # MLP.
        x3 = mlp(x3, hidden_units = transformer_units, dropout_rate = 0.1)
        
        # Conexión de salto 2.
        encoded_patches = L.Add()([x3, x2])

    # Crear un tensor [batch_size, projection_dim].
    representation = L.LayerNormalization(epsilon = 1e-6)(encoded_patches)
    representation = L.Flatten()(representation)
    representation = L.Dropout(0.5)(representation)
    
    # Agregar MLP.
    features = mlp(representation, hidden_units = mlp_head_units, dropout_rate = 0.5)
    
    # Clasificar salidas.
    logits = L.Dense(n_classes)(features)
    
    # Crear el modelo.
    model = tf.keras.Model(inputs = inputs, outputs = logits)
    
    return model
    
decay_steps = train_gen.n // train_gen.batch_size
initial_learning_rate = learning_rate

lr_decayed_fn = tf.keras.experimental.CosineDecay(initial_learning_rate, decay_steps)

lr_scheduler = tf.keras.callbacks.LearningRateScheduler(lr_decayed_fn)

optimizer = tf.keras.optimizers.Adam(learning_rate = learning_rate)

model = vision_transformer()
    
model.compile(optimizer = optimizer, 
              loss = tf.keras.losses.CategoricalCrossentropy(label_smoothing = 0.1), 
              metrics = ['accuracy'])


STEP_SIZE_TRAIN = train_gen.n // train_gen.batch_size
STEP_SIZE_VALID = valid_gen.n // valid_gen.batch_size

earlystopping = tf.keras.callbacks.EarlyStopping(monitor = 'val_accuracy',
                                                 min_delta = 1e-4,
                                                 patience = 5,
                                                 mode = 'max',
                                                 restore_best_weights = True,
                                                 verbose = 1)

checkpointer = tf.keras.callbacks.ModelCheckpoint(filepath = './model.hdf5',
                                                  monitor = 'val_accuracy', 
                                                  verbose = 1, 
                                                  save_best_only = True,
                                                  save_weights_only = True,
                                                  mode = 'max')

callbacks = [earlystopping, lr_scheduler, checkpointer]

model.fit(x = train_gen,
          steps_per_epoch = STEP_SIZE_TRAIN,
          validation_data = valid_gen,
          validation_steps = STEP_SIZE_VALID,
          epochs = num_epochs,
          callbacks = callbacks)
#import csv

Explicación del código

Este código define un modelo personalizado Vision Transformer adaptado a nuestra tarea de clasificación de enfermedades de la yuca. Encapsula múltiples bloques Transformer, cada uno compuesto por capas de atención multi-cabeza, conexiones de salto y perceptrones multicapa (MLPs). El resultado es un modelo robusto capaz de capturar patrones complejos en imágenes de hojas de yuca.

En primer lugar, la función vision_transformer() toma protagonismo al definir el diseño arquitectónico de nuestro Vision Transformer. Esta función describe cómo el modelo procesa y aprende de las imágenes de hojas de yuca, lo que le permite clasificar enfermedades de manera precisa.

Para optimizar aún más el proceso de entrenamiento, implementamos un programador de velocidad de aprendizaje. Este programador utiliza una estrategia de decaimiento coseno, ajustando dinámicamente la velocidad de aprendizaje a medida que el modelo aprende. Esta adaptación dinámica mejora la convergencia del modelo, permitiéndole alcanzar su máximo rendimiento de manera eficiente.

Procedemos a la compilación del modelo una vez que se establece su arquitectura y estrategia de entrenamiento. Durante esta fase, especificamos componentes esenciales como las funciones de pérdida, los optimizadores y las métricas de evaluación. Estos elementos se eligen cuidadosamente para garantizar que nuestro modelo optimice su proceso de aprendizaje, realizando predicciones precisas.

Finalmente, la efectividad del entrenamiento de nuestro modelo se garantiza mediante la aplicación de devoluciones de llamada de entrenamiento. Dos devoluciones de llamada críticas entran en juego: la detención temprana y el punto de control del modelo. La detención temprana supervisa el rendimiento del modelo en los datos de validación e interviene cuando las mejoras se estancan, evitando así el sobreajuste. Al mismo tiempo, el punto de control del modelo registra la versión de mejor rendimiento de nuestro modelo, lo que nos permite conservar su estado óptimo para uso futuro.

Juntos, estos componentes crean un marco integral para desarrollar, entrenar y optimizar nuestro modelo de Vision Transformer, un paso clave en nuestro viaje hacia la clasificación precisa de enfermedades de las hojas de yuca.

Aplicaciones de los ViTs en la Agricultura

La aplicación de los Vision Transformers en la agricultura de yuca va más allá de la investigación y la novedad; ofrece soluciones prácticas a desafíos apremiantes:

Detección temprana de enfermedades: Los ViTs permiten la detección temprana de la CMD y la CBSD, lo que permite a los agricultores tomar medidas rápidas para prevenir la propagación de enfermedades y minimizar las pérdidas de cultivos.
Eficiencia de recursos: Con los ViTs, los recursos como el tiempo y el uso de mano de obra se utilizan de manera más eficiente, ya que la detección automatizada de enfermedades reduce la necesidad de inspección manual de cada planta de yuca.
Agricultura de precisión: Integre los ViTs con otras tecnologías como drones y dispositivos de IoT para la agricultura de precisión, donde se identifican y tratan de manera precisa los puntos calientes de enfermedades.
Mejora de la seguridad alimentaria: Al mitigar el impacto de las enfermedades en los rendimientos de la yuca, los ViTs contribuyen a una mayor seguridad alimentaria en las regiones donde la yuca es un alimento básico.

Ventajas de los Vision Transformers

Los Vision Transformers ofrecen varias ventajas sobre los enfoques tradicionales basados en CNN:

Escalabilidad: Los Vision Transformers pueden manejar imágenes de diferentes resoluciones sin necesidad de realizar cambios en la arquitectura del modelo. Esta escalabilidad es particularmente valiosa en aplicaciones del mundo real donde las imágenes tienen diferentes tamaños.
Contexto global: El mecanismo de autoatención en los Vision Transformers les permite capturar el contexto global de manera efectiva. Esto es crucial para tareas como reconocer objetos en escenas desordenadas.
Menos componentes arquitectónicos: A diferencia de las CNN, los Vision Transformers no requieren componentes arquitectónicos complejos como capas de agrupación y filtros convolucionales. Esto simplifica el diseño y mantenimiento del modelo.
Aprendizaje por transferencia: Los Vision Transformers pueden ser preentrenados en grandes conjuntos de datos, lo que los convierte en excelentes candidatos para el aprendizaje por transferencia. Los modelos preentrenados se pueden ajustar para tareas específicas con cantidades relativamente pequeñas de datos específicos de la tarea.

Desafíos y Direcciones Futuras

Aunque los Vision Transformers han mostrado un progreso notable, también enfrentan varios desafíos:

Recursos computacionales: Entrenar grandes modelos de Vision Transformers requiere recursos computacionales sustanciales, lo que puede ser una barrera para equipos de investigación y organizaciones más pequeñas.
Eficiencia de datos: Los Vision Transformers pueden requerir grandes cantidades de datos, y lograr un rendimiento robusto con datos limitados puede ser un desafío. Desarrollar técnicas para un entrenamiento más eficiente en términos de datos es una preocupación importante.
Interpretabilidad: A menudo se critica a los Transformers por su naturaleza de caja negra. Los investigadores están trabajando en métodos para mejorar la interpretabilidad de los Vision Transformers, especialmente en aplicaciones críticas para la seguridad.
Inferencia en tiempo real: Lograr la inferencia en tiempo real con grandes modelos de Vision Transformers puede ser intensivo en recursos computacionales. Las optimizaciones para una inferencia más rápida son un área de investigación activa.

Conclusión

Los Vision Transformers transforman la agricultura de yuca al ofrecer soluciones precisas y eficientes para la clasificación de enfermedades de las hojas. Su capacidad para procesar datos visuales, junto con los avances en la recopilación de datos y el entrenamiento de modelos, tiene un tremendo potencial para proteger los cultivos de yuca y garantizar la seguridad alimentaria. Aunque persisten desafíos, la investigación en curso y las aplicaciones prácticas impulsan la adopción de los ViTs en la agricultura de yuca. La innovación continua y la colaboración transformarán los ViTs en una herramienta invaluable para los agricultores de yuca en todo el mundo, ya que contribuyen a prácticas agrícolas sostenibles y reducen las pérdidas de cultivos causadas por devastadoras enfermedades de las hojas.

Puntos clave

Los Vision Transformers (ViTs) adaptan la arquitectura del transformador para la visión por computadora, procesando imágenes como secuencias de parches.
Los ViTs, inicialmente diseñados para la visión por computadora, ahora se aplican a la agricultura para abordar desafíos como la detección temprana de enfermedades de las hojas.
Abordan desafíos como los recursos computacionales y la eficiencia de los datos, lo que hace que los ViTs sean una tecnología prometedora para el futuro de la visión por computadora.

Preguntas frecuentes

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