Landwirtschaft und Deep Learning: Verbesserung der Boden- und Pflanzenerträge

Einleitung

Für viele Inder ist die Landwirtschaft mehr als nur ein Beruf; Es ist eine Lebensweise. Es ist das Mittel, mit dem sie ihren Lebensunterhalt bestreiten und einen enormen Beitrag zur indischen Wirtschaft leisten. Die Bestimmung des Bodentyps, der die Ton-, Sand- und Schluffpartikel in den jeweiligen Anteilen enthält, ist wichtig für die geeignete Auswahl der Kulturpflanzen und die Identifizierung des Unkrautwachstums. Entdecken Sie das Potenzial von Deep Learning in der Landwirtschaft. Verstehen Sie die Bedeutung von Bodentypen und Unkrauterkennung für Indien.

Tiefes Lernen ist eine aufstrebende Technologie, die in allen Bereichen hilfreich ist. Deep Learning wird in der intelligenten Landwirtschaft häufig maßstabsübergreifend für die Feldüberwachung, den Feldbetrieb, die Robotik, die Vorhersage von Boden-, Wasser- und Klimabedingungen sowie die Überwachung von Land- und Kulturpflanzenarten auf Landschaftsebene eingesetzt. Wir können das Foto des Bodens in eine Deep-Learning-Architektur einspeisen, es so anleiten, dass es lernt, Merkmale zu erkennen, und dann die Deep-Learning-Architektur verwenden, um den Boden zu klassifizieren.

In diesem Blog diskutieren wir die Bedeutung des Bodens in der Landwirtschaft. Wir werden Böden mithilfe von Modellen des maschinellen Lernens und des Deep Learning klassifizieren.

Lernziele

• Sie werden verstehen, wie wichtig der Boden in der Landwirtschaft ist.
• Sie erfahren, wie maschinelle Lernalgorithmen Bodentypen klassifizieren können.
• Sie implementieren ein Deep-Learning-Modell in der Landwirtschaft, um Bodentypen zu klassifizieren.
• Entdecken Sie das Konzept des Multi-Stacking-Ensemble-Lernens, um die Genauigkeit unserer Vorhersagen zu erhöhen.

Dieser Artikel wurde als Teil des veröffentlicht Data Science-Blogathon.

Die Rolle des Bodens in der Landwirtschaft

Organische Stoffe, Mineralien, Gase, Flüssigkeiten und andere von Pflanzen und Tieren ausgeschiedene Stoffe bilden einen wichtigen Boden, eine Grundlage für die Landwirtschaft. Die Grundlage der Landwirtschaft sind Gase, Mineralien, organische Stoffe und andere Substanzen, die von Pflanzen und Tieren stammen und das Bodensystem bilden.

Indiens Wirtschaft basiert ausschließlich auf der Landwirtschaft; Der Boden ist wichtig für die Kulturpflanzen und führt aufgrund seiner Fruchtbarkeit zur Entwicklung unerwünschter Unkräuter.

Feuchtigkeit und Temperatur sind die physikalischen Variablen, die die Bildung von Poren und Partikeln im Boden beeinflussen und sich auf das Wurzelwachstum, die Wasserinfiltration und die Geschwindigkeit des Pflanzenaufgangs auswirken.

Aber hauptsächlich besteht der Boden aus Sand- und Tonpartikeln. Inmitten der vorherrschenden Bodenpartikel ist im Explorationsgebiet reichlich Ton vorhanden. Die Verfügbarkeit von Tonpartikeln an der Oberfläche ist auf die reichliche Versorgung mit Nährstoffen zurückzuführen. Torf und Lehm sind kaum vorhanden. Der lehmige Boden ist dazwischen weiträumig, wodurch das Wasser zurückgehalten wird.

Datensatz

Kaggle-Link

Die Merkmalsextraktion ist einer der Hauptschritte beim Aufbau eines guten Deep-Learning-Modells. Es ist wichtig, Funktionen zu identifizieren, die für die Erstellung der Algorithmen für maschinelles Lernen erforderlich sein können. Wir werden das verwenden Mahotas Bibliothek zum Extrahieren von Haralick-Merkmalen, die räumliche und Texturinformationen der Bilder enthalten.

Wir werden die Skimage-Bibliothek verwenden, um Bilder in Graustufen zu konvertieren und Histogram of Gradient (HOG)-Funktionen zu extrahieren, die für die Objekterkennung nützlich sind. Abschließend werden wir die Werte der Features in einem Array verketten und sie später in Algorithmen für maschinelles Lernen und Deep Learning verwenden.

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)

Algorithmen des maschinellen Lernens in der Bodenklassifizierung

Lassen Sie uns nun ein Modell für maschinelles Lernen mithilfe der Bodenbilder erstellen, die wir vom Kaggle erhalten haben.

Zuerst importieren wir alle Bibliotheken und erstellen dann eine Funktion mit dem Namen extract_features um Merkmale aus Bildern zu extrahieren. Die Bilder werden dann importiert und verarbeitet, einschließlich der Konvertierung in Graustufen, und dann erhalten wir diese Funktionen. Nachdem die Merkmale für jedes Bild extrahiert wurden, werden die Beschriftungen mit codiert Etikettenkodierer.

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)

Tiefe neuronale Netze

Es funktioniert basierend auf Recheneinheiten und der Anzahl der Neuronen. Jedes Neuron akzeptiert Eingaben und liefert Ausgaben. Es wird verwendet, um die Genauigkeit zu erhöhen und bessere Vorhersagen zu treffen, während Algorithmen für maschinelles Lernen auf der Interpretation der Daten basieren und Entscheidungen auf deren Grundlage getroffen werden.

Lesen Sie auch: Eine Einführung in Deep Learning und neuronale Netze

Lassen Sie uns nun das mithilfe der Sequential API von Keras definierte Modell erstellen. Dieses Modell verfügt über eine Conv2D-Faltungsschicht, MaxPooling2D, eine Abflachungsschicht Flatten und dichte Schichten Dense.

Abschließend wird das Modell mit kompiliert Marcus Optimierer und kategorialer Kreuzentropieverlust.

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)

Wie Sie sehen können, ist die vorhergesagte Klasse 0, also Black Soil. Unser Modell klassifiziert also die Bodenart korrekt.

Vorgeschlagene Multi-Stacking-Ensemble-Lernmodellarchitekturen

Das StackingClassifier wird mit den baseClassifiers und a initialisiert logistische Regression Meta-Klassifikator final_estimator. Dadurch werden die Ausgaben der baseClassifiers kombiniert, um eine endgültige Vorhersage zu treffen. Nach dem Training und der Vorhersage wird dann die Genauigkeit berechnet.

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)

Zusammenfassung

Der Boden ist ein wichtiges Element für eine gute Ernte. Es ist wichtig zu wissen, welcher Bodentyp für den Anbau dieser bestimmten Kulturpflanze erforderlich ist. Daher ist die Klassifizierung der Bodenart wichtig. Da die manuelle Klassifizierung der Bodenart eine zeitaufwändige Aufgabe ist, ist die Verwendung von Deep-Learning-Modellen zur Klassifizierung einfach. Es gibt viele Modelle für maschinelles Lernen und Deep-Learning-Modelle, um diese Problemstellung umzusetzen. Die Auswahl des besten hängt von der Qualität und Menge der im Datensatz vorhandenen Daten sowie der vorliegenden Problemstellung ab. Eine andere Möglichkeit, den besten Algorithmus auszuwählen, besteht darin, jeden einzelnen zu bewerten. Wir können dies erreichen, indem wir die Genauigkeit messen, inwieweit sie den Boden korrekt klassifizieren können. Schließlich haben wir ein Multi-Stacking-Ensemblemodell implementiert und dabei mehrere Modelle verwendet, um das beste Modell zu erstellen.

Key Take Away

• Für eine effektive Pflanzenauswahl sollte man den Boden vollständig verstehen.
• Deep Learning in der Landwirtschaft ist ein leistungsstarkes Werkzeug, von der Vorhersage von Pflanzenkrankheiten bis hin zu Bodentypen und Wasserbedarf.
• Wir haben eine Merkmalsextraktion durchgeführt, um Merkmale aus Bodenbildern zu erhalten.
• In diesem Blog haben wir maschinelles Lernen und Deep-Learning-Modelle zur Bodenklassifizierung sowie ein Multi-Stacked-Ensemble-Modell für eine verbesserte Genauigkeit untersucht.

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Verbunden

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
• PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
• PlatoESG. Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
• PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
• Quelle: https://www.analyticsvidhya.com/blog/2024/01/deep-learning-in-agriculture-improving-soil-crop-yields/