Agriculture et apprentissage profond : améliorer les rendements des sols et des cultures

Introduction

L'agriculture est plus qu'un simple travail pour de nombreux Indiens ; C'est une manière de vivre. C'est le moyen par lequel ils subviennent à leurs moyens de subsistance et contribuent énormément à l'économie indienne. La détermination du type de sol contenant des particules d'argile, de sable et de limon dans les proportions respectives est importante pour la sélection des cultures appropriées et l'identification de la croissance des mauvaises herbes. Découvrez le potentiel du Deep Learning en agriculture. Comprendre l'importance des types de sols et de la détection des mauvaises herbes pour l'Inde.

L'apprentissage en profondeur est une technologie émergente utile dans tous les domaines. L'apprentissage profond a été largement appliqué à l'agriculture intelligente à plusieurs échelles pour la surveillance des champs, les opérations sur le terrain, la robotique, la prévision des sols, de l'eau, des conditions climatiques et la surveillance des terres et des types de cultures au niveau du paysage. Nous pouvons transmettre la photo du sol à une architecture d’apprentissage profond, la guider pour apprendre à détecter des caractéristiques, puis utiliser l’architecture d’apprentissage profond pour classer le sol.

Dans ce blog, nous discuterons de l'importance du sol dans l'agriculture. Nous classifierons les sols à l’aide de modèles d’apprentissage automatique et d’apprentissage profond.

Objectifs d'apprentissage

• Vous comprendrez à quel point le sol est important en agriculture.
• Vous apprendrez comment les algorithmes d'apprentissage automatique peuvent classer les types de sols.
• Vous mettrez en œuvre un modèle d'apprentissage profond en agriculture pour classer les types de sols.
• Explorez le concept d'apprentissage d'ensemble multi-empilement pour augmenter la précision de nos prédictions.

Cet article a été publié dans le cadre du Blogathon sur la science des données.

Le rôle du sol dans l'agriculture

La matière organique, les minéraux, les gaz, les liquides et autres substances excrétées par les plantes et les animaux constituent un sol important, fondement de l'agriculture. Le fondement de l’agriculture réside dans les gaz, les minéraux, la matière organique et d’autres substances provenant des plantes et des animaux, qui forment le système du sol.

L'économie indienne repose uniquement sur l'agriculture ; le sol est important pour les cultures et conduit au développement de mauvaises herbes indésirables en raison de sa fertilité.

L'humidité et la température sont des variables physiques qui ont un impact sur la formation de pores et de particules dans le sol, affectant la croissance des racines, l'infiltration de l'eau et la vitesse d'émergence des plantes.

Mais surtout, le sol contient des particules de sable et d’argile. Parmi les particules de sol largement disponibles, l’argile est abondante sur le site d’exploration. La disponibilité des particules d'argile à la surface est due à l'abondance de la nutrition fournie. La tourbe et le limon sont peu présents. Le sol de type argileux est spacieux entre les deux, dans lequel l'eau est retenue.

Ensemble de données

Lien Kaggle

L'extraction de fonctionnalités est l'une des principales étapes de la création d'un bon modèle d'apprentissage en profondeur. Il est important d’identifier les fonctionnalités qui peuvent être nécessaires à la création des algorithmes d’apprentissage automatique. Nous utiliserons le Mahotas bibliothèque pour extraire les fonctionnalités Haralick, qui contiennent des informations spatiales et de texture des images.

Nous utiliserons la bibliothèque skimage pour convertir les images en niveaux de gris et extraire les fonctionnalités d'histogramme de dégradé (HOG) qui sont utiles pour la détection d'objets. Enfin, nous concaténerons les valeurs des caractéristiques dans un tableau et les utiliserons plus tard dans des algorithmes d'apprentissage automatique et d'apprentissage profond.

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)

Algorithmes d'apprentissage automatique dans la classification des sols

Maintenant, construisons un modèle d'apprentissage automatique en utilisant les images de sol que nous avons obtenues du Kaggle.

Tout d’abord, nous importerons toutes les bibliothèques puis construirons une fonction nommée extrait_features pour extraire des caractéristiques des images. Les images sont ensuite importées et traitées, ce qui inclut la conversion en niveaux de gris, puis nous obtenons ces fonctionnalités. Ensuite, une fois les caractéristiques extraites de chaque image, les étiquettes sont codées à l'aide de Encodeur d'étiquette.

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)

Réseaux neuronaux profonds

Il fonctionne en fonction des unités de calcul et du nombre de neurones. Chaque neurone accepte les entrées et fournit une sortie. Il est utilisé pour augmenter la précision et faire de meilleures prédictions, tandis que les algorithmes d’apprentissage automatique reposent sur l’interprétation des données et que les décisions seront prises en fonction de celles-ci.

Lire aussi: Un guide d'introduction à l'apprentissage profond et aux réseaux de neurones

Maintenant, construisons le modèle défini à l'aide de l'API séquentielle de Keras. Ce modèle aura une couche de convolution Conv2D, MaxPooling2D, une couche d'aplatissement Flatten et des couches denses Dense.

Enfin, le modèle est compilé à l'aide de Adam optimiseur et perte d'entropie croisée catégorique.

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)

Comme vous pouvez le voir, la classe prédite est 0, ce qui correspond au sol noir. Ainsi, notre modèle classe correctement le type de sol.

Architectures de modèles d'apprentissage d'ensemble multi-empilement proposées

La StackingClassifier est initialisé avec les baseClassifiers et un régression logistique méta-classificateur final_estimator. Cela combine les sorties des baseClassifiers pour faire une prédiction finale. Ensuite, après entraînement et prédiction, la précision est calculée.

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)

Conclusion

Le sol est un élément important pour obtenir une bonne récolte. Il est important de savoir quel type de sol est nécessaire pour produire cette culture spécifique. Ainsi, classer le type de sol devient important. Étant donné que la classification manuelle du type de sol est une tâche fastidieuse, il devient donc facile d'utiliser des modèles d'apprentissage en profondeur pour les classer. Il existe de nombreux modèles d’apprentissage automatique et d’apprentissage profond pour mettre en œuvre cet énoncé du problème. Le choix du meilleur dépend de la qualité et de la quantité des données présentes dans l'ensemble de données et de l'énoncé du problème en question. Une autre façon de choisir le meilleur algorithme consiste à évaluer chacun d’eux. Nous pouvons le faire en mesurant la précision, dans quelle mesure ils peuvent classer correctement le sol. Enfin, nous avons implémenté un modèle d'ensemble Multi-Stacking, utilisant plusieurs modèles pour construire le meilleur modèle.

Faits marquants

• Pour une sélection efficace des cultures, il faut bien comprendre le sol.
• L’apprentissage profond en agriculture est un outil puissant, qu’il s’agisse de prédire les maladies des plantes, les types de sols ou les besoins en eau.
• Nous avons effectué une extraction de caractéristiques pour obtenir des caractéristiques à partir d'images de sol.
• Dans ce blog, nous avons exploré des modèles d'apprentissage automatique et d'apprentissage profond pour classer les sols, ainsi qu'un modèle d'ensemble multi-empilé pour une précision améliorée.

Foire aux Questions

Les médias présentés dans cet article n'appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l'auteur.

Services Connexes

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• La source: https://www.analyticsvidhya.com/blog/2024/01/deep-learning-in-agriculture-improving-soil-crop-yields/