Landbouw en diepgaand leren: verbetering van de bodem- en gewasopbrengsten

Introductie

Landbouw is voor veel Indiërs meer dan alleen een baan; het is een manier van leven. Het is het middel waarmee ze in hun levensonderhoud voorzien en een enorme bijdrage leveren aan de Indiase economie. Bepaling van het type grond met de klei-, zand- en slibdeeltjes in de respectieve verhoudingen is belangrijk voor een geschikte gewasselectie en het identificeren van de groei van het onkruid. Ontdek het potentieel van Deep Learning in de landbouw. Begrijp het belang van bodemsoorten en onkruiddetectie voor India.

Diepe leer is een opkomende technologie die op elk gebied nuttig is. Deep learning wordt in de slimme landbouw op grote schaal toegepast voor veldmonitoring, veldoperaties, robotica, het voorspellen van bodem, water, klimaatomstandigheden en monitoring van land- en gewastypen op landschapsniveau. We kunnen de foto van de bodem aan een deep learning-architectuur koppelen, deze begeleiden bij het leren detecteren van kenmerken en vervolgens de deep learning-architectuur gebruiken om de bodem te classificeren.

In deze blog bespreken we het belang van de bodem in de landbouw. We zullen de bodem classificeren met behulp van machine learning en deep learning-modellen.

leerdoelen

• Je zult begrijpen hoe belangrijk de bodem is in de landbouw.
• Je leert hoe machine learning-algoritmen bodemtypen kunnen classificeren.
• Je implementeert een deep learning-model in de landbouw om bodemtypes te classificeren.
• Ontdek het concept van multi-stapelend ensemble-leren om de nauwkeurigheid van onze voorspellingen te vergroten.

Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

De rol van de bodem in de landbouw

Organische stoffen, mineralen, gassen, vloeistoffen en andere stoffen die door planten en dieren worden uitgescheiden, vormen een belangrijke bodem, een basis voor de landbouw. De basis van de landbouw ligt in de gassen, mineralen, organische stoffen en andere stoffen die afkomstig zijn van planten en dieren en die het bodemsysteem vormen.

De Indiase economie is puur afhankelijk van de landbouw; de bodem is belangrijk voor de gewassen en leidt vanwege de vruchtbaarheid ervan tot de ontwikkeling van ongewenst onkruid.

Vocht en temperatuur zijn de fysieke variabelen die van invloed zijn op de vorming van poriën en deeltjes in de bodem, waardoor de wortelgroei, de waterinfiltratie en de snelheid van het opkomen van planten worden beïnvloed.

Maar de bodem bestaat vooral uit zand- en kleideeltjes. Te midden van de overwegend beschikbare bodemdeeltjes is klei in overvloed aanwezig op de onderzoekslocatie. De beschikbaarheid van kleideeltjes op het oppervlak is te danken aan de overvloedige aangevoerde voeding. De turf en leem zijn nauwelijks aanwezig. De kleiachtige grond ligt daartussen ruim, waarbij het water wordt vastgehouden.

dataset

Kaggle-link

Functie-extractie is een van de belangrijkste stappen bij het bouwen van een goed deep-learning-model. Het is belangrijk om functies te identificeren die mogelijk nodig zijn voor het bouwen van machine learning-algoritmen. Wij zullen gebruik maken van de Mahota's bibliotheek om Haralick-kenmerken te extraheren, die ruimtelijke en textuurinformatie van de afbeeldingen bevatten.

We zullen de skimage-bibliotheek gebruiken om afbeeldingen naar grijswaarden te converteren en om Histogram of Gradient (HOG)-functies te extraheren die handig zijn voor objectdetectie. Ten slotte zullen we de waarden van de functies samenvoegen tot een array en deze later gebruiken in machine learning en deep learning-algoritmen.

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)

Machine learning-algoritmen in bodemclassificatie

Laten we nu een machinaal leermodel bouwen met behulp van de bodembeelden die we van de Kaggle hebben gekregen.

Eerst zullen we alle bibliotheken importeren en vervolgens een functie bouwen met de naam extract_functies om kenmerken uit afbeeldingen te extraheren. De afbeeldingen worden vervolgens geïmporteerd en verwerkt, inclusief conversie naar grijswaarden, en dan krijgen we deze functies. Nadat de kenmerken voor elke afbeelding zijn geëxtraheerd, worden de labels gecodeerd met behulp van Label-encoder.

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)

Deep Neural Networks

Het werkt op basis van rekeneenheden en het aantal neuronen. Elk neuron accepteert input en levert output. Het wordt gebruikt om de nauwkeurigheid te vergroten en betere voorspellingen te doen, terwijl machine learning-algoritmen afhankelijk zijn van het interpreteren van de gegevens en op basis daarvan beslissingen zullen worden genomen.

Lees ook: Een inleidende gids voor diep leren en neurale netwerken

Laten we nu het model bouwen dat is gedefinieerd met behulp van Sequential API van Keras. Dit model heeft een Conv2D-convolutielaag, MaxPooling2D, een afvlakkende laag Flatten en dichte lagen Dense.

Tenslotte wordt het model samengesteld met behulp van de Adam optimizer en categorisch kruis-entropieverlies.

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)

Zoals u kunt zien, is de voorspelde klasse 0, wat Black Soil is. Ons model classificeert het grondtype dus correct.

Voorgestelde multi-stapelende ensemble-leermodelarchitecturen

De StackingClassifier wordt geïnitialiseerd met de baseClassifiers en a logistische regressie meta-classificator uiteindelijke_schatter. Dit combineert de uitvoer van de baseClassifiers om een ​​definitieve voorspelling te doen. Vervolgens wordt, na training en voorspellen, de nauwkeurigheid berekend.

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)

Conclusie

Bodem is een belangrijk element bij het opleveren van een goede oogst. Het is belangrijk om te weten welke grondsoort nodig is om dat specifieke gewas te produceren. Het classificeren van het type grond wordt dus belangrijk. Omdat het handmatig classificeren van het bodemtype een tijdrovende taak is, wordt het gebruik van deep learning-modellen om deze te classificeren eenvoudig. Er zijn veel machine learning-modellen en deep learning-modellen om deze probleemstelling te implementeren. Het kiezen van de beste hangt af van de kwaliteit en de hoeveelheid gegevens in de dataset en de probleemstelling die voorhanden is. Een andere manier om het beste algoritme te kiezen is door elk algoritme te evalueren. We kunnen dat doen door de nauwkeurigheid te meten, in hoeverre ze de grond correct kunnen classificeren. Ten slotte hebben we een Multi-Stacking-ensemblemodel geïmplementeerd, waarbij we meerdere modellen hebben gebruikt om het beste model te bouwen.

Key Takeaways

• Voor een effectieve gewasselectie moet men de bodem volledig begrijpen.
• Diep leren in de landbouw is een krachtig hulpmiddel, van het voorspellen van plantenziekten tot bodemtypes en waterbehoeften.
• We hebben kenmerkextractie uitgevoerd om kenmerken uit bodembeelden te halen.
• In deze blog hebben we machine learning- en deep learning-modellen onderzocht voor het classificeren van grond en een Multi-stacked ensemble-model voor verbeterde nauwkeurigheid.

Veelgestelde Vragen / FAQ

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt.

Verwant

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://www.analyticsvidhya.com/blog/2024/01/deep-learning-in-agriculture-improving-soil-crop-yields/