Agricultura e aprendizagem profunda: melhorando o rendimento do solo e das colheitas

Introdução

A agricultura é mais do que apenas um emprego para muitos indianos; É um modo de vida. É o meio através do qual eles sustentam a sua subsistência e contribuem imensamente para a economia da Índia. A determinação do tipo de solo que contém partículas de argila, areia e silte nas respectivas proporções é importante para a seleção adequada da cultura e identificação do crescimento da erva daninha. Descubra o potencial do Deep Learning na Agricultura. Compreenda a importância dos tipos de solo e da detecção de ervas daninhas para a Índia.

Aprendizado profundo é uma tecnologia emergente que é útil em todos os campos. A aprendizagem profunda tem sido popularmente aplicada na agricultura inteligente em várias escalas para monitoramento de campo, operação de campo, robótica, previsão de solo, água, condições climáticas e monitoramento de terras e tipos de culturas em nível de paisagem. Podemos alimentar a foto do solo para uma arquitetura de aprendizado profundo, orientá-la para aprender a detectar características e, em seguida, usar a arquitetura de aprendizado profundo para classificar o solo.

Neste blog, discutiremos a importância do solo na agricultura. Classificaremos o solo usando modelos de aprendizado de máquina e aprendizado profundo.

Objetivos de aprendizagem

• Você entenderá a importância do solo na agricultura.
• Você aprenderá como algoritmos de aprendizado de máquina podem classificar os tipos de solo.
• Você implementará um modelo de aprendizado profundo na agricultura para classificar os tipos de solo.
• Explore o conceito de aprendizagem de conjunto multiempilhamento para aumentar a precisão de nossas previsões.

Este artigo foi publicado como parte do Blogatona de Ciência de Dados.

O papel do solo na agricultura

Matéria orgânica, minerais, gases, líquidos e outras substâncias excretadas de plantas e animais formam um solo importante, uma base para a agricultura. A base da agricultura reside nos gases, minerais, matéria orgânica e outras substâncias provenientes de plantas e animais, formando o sistema do solo.

A economia da Índia depende exclusivamente da agricultura; o solo é importante para as culturas e leva ao desenvolvimento de ervas daninhas indesejadas devido à sua fertilidade.

A umidade e a temperatura são as variáveis ​​físicas que impactam na formação de poros e partículas no solo, afetando o crescimento das raízes, a infiltração de água e a velocidade de emergência das plantas.

Mas principalmente o solo contém partículas de areia e argila. Entre as partículas de solo predominantemente disponíveis, a argila é abundante no local de exploração. A disponibilidade de partículas de argila na superfície se deve à abundante nutrição fornecida. A turfa e a argila quase não estão presentes. O solo argiloso é espaçoso no meio, onde a água fica retida.

Conjunto de dados

Link do Kaggle

A extração de recursos é uma das principais etapas na construção de um bom modelo de aprendizado profundo. É importante identificar recursos que podem ser necessários para a construção dos algoritmos de aprendizado de máquina. Usaremos o Mahotas biblioteca para extrair recursos Haralick, que possuem informações espaciais e de textura das imagens.

Usaremos a biblioteca skimage para converter imagens em tons de cinza e extrair recursos de histograma de gradiente (HOG) que são úteis para detecção de objetos. Por fim, concatenaremos os valores dos recursos em um array e posteriormente os usaremos em algoritmos de aprendizado de máquina e aprendizado 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 Aprendizado de Máquina na Classificação de Solos

Agora, vamos construir um modelo de aprendizado de máquina usando as imagens de solo que obtivemos do Kaggle.

Primeiro, importaremos todas as bibliotecas e depois construiremos uma função chamada extrair_features para extrair recursos de imagens. As imagens são então importadas e processadas, o que inclui a conversão para tons de cinza, e então obtemos esses recursos. Então, depois que os recursos são extraídos para cada imagem, os rótulos são codificados usando Codificador de etiqueta.

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 Neurais Profundas

Funciona com base em unidades de computação e no número de neurônios. Cada neurônio aceita entradas e fornece saída. Ele é usado para aumentar a precisão e fazer melhores previsões, enquanto os algoritmos de aprendizado de máquina dependem da interpretação dos dados e as decisões serão tomadas com base neles.

Leia também: Um guia introdutório ao aprendizado profundo e redes neurais

Agora, vamos construir o modelo definido usando a API Sequential da Keras. Este modelo terá uma camada de convolução Conv2D, MaxPooling2D, uma camada de achatamento Flatten e camadas densas Dense.

Por fim, o modelo é compilado usando o Adam  otimizador e perda categórica de entropia 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 você pode ver, a classe prevista é 0, que é Solo Negro. Portanto, nosso modelo está classificando corretamente o tipo de solo.

Arquiteturas propostas de modelo de aprendizagem de conjunto multi-empilhamento

A StackingClassificador é inicializado com baseClassifiers e um regressão logística metaclassificador estimador_final. Isso combina as saídas dos baseClassifiers para fazer uma previsão final. Então, após treinamento e previsão, a precisão é calculada.

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)

Conclusão

O solo é um elemento importante para produzir uma boa colheita. É importante saber que tipo de solo é necessário para produzir aquela cultura específica. Portanto, classificar o tipo de solo torna-se importante. Como classificar manualmente o tipo de solo é uma tarefa demorada, torna-se fácil usar modelos de aprendizado profundo para classificá-los. Existem muitos modelos de aprendizado de máquina e modelos de aprendizado profundo para implementar esta definição de problema. A escolha do melhor depende da qualidade e quantidade dos dados presentes no conjunto de dados e da definição do problema em questão. Outra forma de escolher o melhor algoritmo é avaliando cada um. Podemos fazer isso medindo a precisão, pelo quanto eles conseguem classificar corretamente o solo. Por fim, implementamos um modelo de conjunto Multi-Stacking, utilizando múltiplos modelos para construir o melhor modelo.

Principais lições

• Para uma seleção eficaz da cultura, deve-se compreender completamente o solo.
• A aprendizagem profunda na agricultura é uma ferramenta poderosa, desde a previsão de doenças de plantas até tipos de solo e necessidades de água.
• Fizemos extração de características para obter características de imagens de solo.
• Neste blog, exploramos modelos de aprendizado de máquina e aprendizado profundo para classificar solo e um modelo de conjunto multiempilhado para maior precisão.

Perguntas Frequentes

A mídia mostrada neste artigo não é propriedade da Analytics Vidhya e é usada a critério do Autor.

Relacionado

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://www.analyticsvidhya.com/blog/2024/01/deep-learning-in-agriculture-improving-soil-crop-yields/