Agricultura y aprendizaje profundo: mejora del rendimiento del suelo y los cultivos

Introducción

La agricultura es más que un simple trabajo para muchos indios; Es un modo de vida. Es el medio a través del cual sustentan sus medios de vida y contribuyen inmensamente a la economía de la India. La determinación del tipo de suelo que tiene partículas de arcilla, arena y limo en las proporciones respectivas es importante para seleccionar el cultivo adecuado e identificar el crecimiento de malezas. Descubra el potencial del Deep Learning en Agricultura. Comprenda la importancia de los tipos de suelo y la detección de malezas para la India.

Aprendizaje profundo es una tecnología emergente que es útil en todos los campos. El aprendizaje profundo se ha aplicado popularmente en la agricultura inteligente en todas las escalas para el monitoreo de campo, las operaciones de campo, la robótica, la predicción del suelo, el agua, las condiciones climáticas y el monitoreo de tipos de tierras y cultivos a nivel de paisaje. Podemos alimentar la fotografía del suelo a una arquitectura de aprendizaje profundo, guiarla para que aprenda a detectar características y luego usar la arquitectura de aprendizaje profundo para clasificar el suelo.

En este blog, discutiremos la importancia del suelo en la agricultura. Clasificaremos el suelo utilizando modelos de aprendizaje automático y aprendizaje profundo.

OBJETIVOS DE APRENDIZAJE

• Comprenderás lo importante que es el suelo en la agricultura.
• Aprenderá cómo los algoritmos de aprendizaje automático pueden clasificar los tipos de suelo.
• Implementarás un modelo de aprendizaje profundo en agricultura para clasificar tipos de suelo.
• Explore el concepto de aprendizaje en conjunto de apilamiento múltiple para aumentar la precisión de nuestras predicciones.

Este artículo fue publicado como parte del Blogatón de ciencia de datos.

El papel del suelo en la agricultura

La materia orgánica, los minerales, los gases, los líquidos y otras sustancias excretadas por las plantas y los animales forman un suelo importante, base para la agricultura. La base de la agricultura radica en los gases, minerales, materia orgánica y otras sustancias que provienen de plantas y animales, formando el sistema del suelo.

La economía de la India depende exclusivamente de la agricultura; El suelo es importante para los cultivos y conduce al desarrollo de malezas no deseadas debido a su fertilidad.

La humedad y la temperatura son las variables físicas que impactan la formación de poros y partículas en el suelo, afectando el crecimiento de las raíces, la infiltración de agua y la velocidad de emergencia de las plantas.

Pero principalmente, el suelo tiene partículas de arena y arcilla. Entre las partículas de suelo predominantemente disponibles, en el sitio de exploración abunda la arcilla. La disponibilidad de partículas de arcilla en la superficie se debe a la abundante nutrición suministrada. La turba y la marga apenas están presentes. El suelo arcilloso es espacioso en el medio, donde se retiene el agua.

Conjunto de datos

Enlace Kaggle

La extracción de características es uno de los pasos principales para construir un buen modelo de aprendizaje profundo. Es importante identificar las características que pueden ser necesarias para crear algoritmos de aprendizaje automático. Usaremos el mahotas Biblioteca para extraer características de Haralick, que tienen información espacial y de textura de las imágenes.

Usaremos la biblioteca skimage para convertir imágenes a escala de grises y extraer características de histograma de gradiente (HOG) que son útiles para la detección de objetos. Finalmente, concatenaremos los valores de las características en una matriz y luego los usaremos en algoritmos de aprendizaje automático y aprendizaje profundo.

import mahotas as mh
from skimage import color, feature, io
import numpy as np

# Function to extract features from an image
def extract_features(image_path):
    img = io.imread(image_path)
    gray_img = color.rgb2gray(img)  # Converting image to grayscale
    
    # Converting the grayscale image to integer type
    gray_img_int = (gray_img * 255).astype(np.uint8)
    
    # Extracting Haralick features using mahotas
    haralick_features = mh.features.haralick(gray_img_int).mean(axis=0)
    
    # Extracting Histogram of Gradients (HOG) features
    hog_features, _ = feature.hog(gray_img, visualize=True)
    
    # Printing the first few elements of each feature array
    print("Haralick Features:", haralick_features[:5])
    print("HOG Features:", hog_features[:5])
    
    # Concatenating the features into a single array
    all_features = np.concatenate((haralick_features, hog_features))
    
    return all_features

image_path = '/kaggle/input/soil-classification-dataset/Soil-Dataset/Yellow Soil/20.jpg'
features = extract_features(image_path)
print("Extracted Features:", features)

Algoritmos de aprendizaje automático en la clasificación de suelos

Ahora, construyamos un modelo de aprendizaje automático utilizando las imágenes del suelo que obtuvimos de Kaggle.

Primero, importaremos todas las bibliotecas y luego crearemos una función llamada extraer_características para extraer características de imágenes. Luego, las imágenes se importan y procesan, lo que incluye la conversión a escala de grises, y luego obtenemos estas características. Luego, después de extraer las características de cada imagen, las etiquetas se codifican usando Codificador de etiquetas.

import os
import numpy as np
import mahotas as mh
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.ensemble import RandomForestClassifier, StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report
from skimage import color, feature, io

# Function to extract features from an image
def extract_features(image_path):
    img = io.imread(image_path)
    gray_img = color.rgb2gray(img)  # Converting image to grayscale
    gray_img_int = (gray_img * 255).astype(np.uint8)
    haralick_features = mh.features.haralick(gray_img_int).mean(axis=0)
    hog_features, _ = feature.hog(gray_img, visualize=True)
    hog_features_flat = hog_features.flatten()  # Flattening the HOG features
    # Ensuring both sets of features have the same length
    hog_features_flat = hog_features_flat[:haralick_features.shape[0]]
    return np.concatenate((haralick_features, hog_features_flat))

data_dir = "/kaggle/input/soil-classification-dataset/Soil-Dataset"

image_paths = []
labels = []

class_indices = {'Black Soil': 0, 'Cinder Soil': 1, 'Laterite Soil': 2, 
'Peat Soil': 3, 'Yellow Soil': 4}

for soil_class, class_index in class_indices.items():
    class_dir = os.path.join(data_dir, soil_class)
    class_images = [os.path.join(class_dir, image) for image in os.listdir(class_dir)]
    image_paths.extend(class_images)
    labels.extend([class_index] * len(class_images))

# Extracting features from images
X = [extract_features(image_path) for image_path in image_paths]

# Encoding labels
le = LabelEncoder()
y = le.fit_transform(labels)

# Splitting the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Initializing and training a Random Forest Classifier
rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)
rf_classifier.fit(X_train, y_train)

# Making predictions
y_pred_rf = rf_classifier.predict(X_test)

# Evaluating the Random Forest model
accuracy_rf = accuracy_score(y_test, y_pred_rf)
report_rf = classification_report(y_test, y_pred_rf)

print("Random Forest Classifier:")
print("Accuracy:", accuracy_rf)
print("Classification Report:n", report_rf)

Redes neuronales profundas

Funciona en base a unidades de cómputo y al número de neuronas. Cada neurona acepta entradas y proporciona salidas. Se utiliza para aumentar la precisión y hacer mejores predicciones, mientras que los algoritmos de aprendizaje automático se basan en la interpretación de los datos y se tomarán decisiones en función de ellos.

Leer también: Una guía introductoria al aprendizaje profundo y las redes neuronales

Ahora, construyamos el modelo definido usando la API secuencial de Keras. Este modelo tendrá una capa de convolución Conv2D, MaxPooling2D, una capa de aplanamiento Flatten y capas densas Dense.

Finalmente, el modelo se compila utilizando el Adam optimizador y pérdida categórica de entropía cruzada.

import tensorflow as tf
from tensorflow.keras.preprocessing import image_dataset_from_directory

data_dir = "/kaggle/input/soil-classification-dataset/Soil-Dataset"

# Setting up data generators
batch_size = 32
image_size = (224, 224)

# Using image_dataset_from_directory to load and preprocess the images
train_dataset = image_dataset_from_directory(
    data_dir,
    labels='inferred',
    label_mode='categorical',
    validation_split=0.2,
    subset='training',
    seed=42,
    image_size=image_size,
    batch_size=batch_size,
)

validation_dataset = image_dataset_from_directory(
    data_dir,
    labels='inferred',
    label_mode='categorical',
    validation_split=0.2,
    subset='validation',
    seed=42,
    image_size=image_size,
    batch_size=batch_size,
)

# Displaying the class indices
print("Class indices:", train_dataset.class_names)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(224, 224, 3)),
    tf.keras.layers.MaxPooling2D(2, 2),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(len(train_dataset.class_names), activation='softmax')
])

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Training the model
epochs = 10
history = model.fit(train_dataset, epochs=epochs, validation_data=validation_dataset)

import numpy as np
from tensorflow.keras.preprocessing import image

# Function to load and preprocess an image for prediction
def load_and_preprocess_image(img_path):
    img = image.load_img(img_path, target_size=image_size)
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)
    img_array /= 255.0  
    return img_array

image_path = '/kaggle/input/soil-classification-dataset/Soil-Dataset/Peat Soil/13.jpg'
new_image = load_and_preprocess_image(image_path)

# Making predictions
predictions = model.predict(new_image)
predicted_class = np.argmax(predictions[0])

# Getting the class label based on the class indices
class_labels = {0: 'Black Soil', 1: 'Cinder Soil', 2: 'Laterite Soil',
 3: 'Peat Soil', 4: 'Yellow Soil'}
predicted_label = class_labels[predicted_class]

# Displaying the prediction
print("Predicted Class:", predicted_class)
print("Predicted Label:", predicted_label)

Como puede ver, la clase prevista es 0, que es Black Soil. Entonces, nuestro modelo clasifica correctamente el tipo de suelo.

Arquitecturas propuestas de modelos de aprendizaje por conjuntos de apilamiento múltiple

La Clasificador de apilamiento se inicializa con los clasificadores base y un regresión logística metaclasificador estimador_final. Esto combina las salidas de los clasificadores base para hacer una predicción final. Luego, después del entrenamiento y la predicción, se calcula la precisión.

base_classifiers = [
    ('rf', RandomForestClassifier(n_estimators=100, random_state=42)),
    ('knn', KNeighborsClassifier(n_neighbors=5)),
    ('svm', SVC(kernel='rbf', C=1.0, probability=True)),
    ('nb', GaussianNB())
]

# Initializing the stacking classifier with a logistic regression meta-classifier
stacking_classifier = StackingClassifier(estimators=base_classifiers, 
final_estimator=LogisticRegression())

# Training the stacking classifier
stacking_classifier.fit(X_train, y_train)

# Making predictions with Stacking Classifier
y_pred_stacking = stacking_classifier.predict(X_test)

# Evaluating the Stacking Classifier model
accuracy_stacking = accuracy_score(y_test, y_pred_stacking)
report_stacking = classification_report(y_test, y_pred_stacking)

print("nStacking Classifier:")
print("Accuracy:", accuracy_stacking)
print("Classification Report:n", report_stacking)

Conclusión

El suelo es un elemento importante para producir una buena cosecha. Es importante saber qué tipo de suelo es necesario para producir ese cultivo específico. Por eso, clasificar el tipo de suelo se vuelve importante. Dado que clasificar manualmente el tipo de suelo es una tarea que requiere mucho tiempo, utilizar modelos de aprendizaje profundo para clasificarlos resulta fácil. Existen muchos modelos de aprendizaje automático y modelos de aprendizaje profundo para implementar este planteamiento del problema. Elegir el mejor depende de la calidad y la cantidad de datos presentes en el conjunto de datos y del planteamiento del problema en cuestión. Otra forma de elegir el mejor algoritmo es evaluando cada uno de ellos. Podemos hacerlo midiendo la precisión, en qué medida pueden clasificar correctamente el suelo. Finalmente, implementamos un modelo de conjunto de apilamiento múltiple, utilizando múltiples modelos para construir el mejor modelo.

Puntos clave

• Para una selección eficaz de cultivos, se debe conocer completamente el suelo.
• El aprendizaje profundo en agricultura es una herramienta poderosa, desde la predicción de enfermedades de las plantas hasta los tipos de suelo y las necesidades de agua.
• Hemos realizado una extracción de características para obtener características de imágenes del suelo.
• En este blog, exploramos modelos de aprendizaje automático y aprendizaje profundo para clasificar suelos y un modelo de conjunto multiapilado para mejorar la precisión.

Preguntas frecuentes

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

Relacionado:

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
• Fuente: https://www.analyticsvidhya.com/blog/2024/01/deep-learning-in-agriculture-improving-soil-crop-yields/