Landbruk og dyp læring: Forbedring av jord- og avlingsavlinger

Publisert av Platon

Følgere: 0

Introduksjon

Landbruk er mer enn bare en jobb for mange indere; det er en livsstil. Det er midlene som de støtter sitt levebrød og bidrar enormt til Indias økonomi. Bestemmelse av type jord som har leire-, sand- og siltpartiklene i de respektive proporsjonene er viktig for egnet avlingsvalg og identifisering av ugressets vekst. Oppdag potensialet til Deep Learning in Agriculture. Forstå viktigheten av jordtyper og ugressdeteksjon for India.

Dyp læring er en ny teknologi som er nyttig på alle felt. Dyplæring har blitt populært brukt i smart landbruk på tvers av skalaer for feltovervåking, feltdrift, robotikk, prediksjon av jord, vann, klimaforhold og overvåking av land- og avlingstyper på landskapsnivå. Vi kan mate bildet av jord til en dyplæringsarkitektur, veilede det til å lære å oppdage funksjoner, og deretter bruke dyplæringsarkitekturen til å klassifisere jorda.

I denne bloggen skal vi diskutere betydningen av jord i landbruket. Vi vil klassifisere jord ved hjelp av maskinlæring og dyplæringsmodeller.

Læringsmål

Du vil forstå hvor viktig jord er i landbruket.
Du vil lære hvordan maskinlæringsalgoritmer kan klassifisere jordtyper.
Du vil implementere en dyp læringsmodell i landbruket for å klassifisere jordtyper.
Utforsk konseptet med flerstabling av ensemblelæring for å øke nøyaktigheten til våre spådommer.

Denne artikkelen ble publisert som en del av Data Science Blogathon.

Innholdsfortegnelse

Jordens rolle i landbruket

Organisk materiale, mineraler, gasser, væsker og andre stoffer som skilles ut fra planter og dyr danner viktig jord, et grunnlag for jordbruk. Grunnlaget for landbruket ligger i gassene, mineralene, organisk materiale og andre stoffer som kommer fra planter og dyr, og danner jordsystemet.

Indias økonomi er utelukkende avhengig av landbruk; jorda er viktig for avlingene, og det fører til utvikling av uønsket ugress på grunn av fruktbarheten.

Jordens rolle i landbruket | Dyplæring i landbruket

Fuktighet og temperatur er de fysiske variablene som påvirker dannelsen av porer og partikler i jorda, og påvirker rotvekst, vanninfiltrasjon og plantens fremveksthastighet.

Men hovedsakelig har jorda partikler av sand og leire. Blant de mest tilgjengelige jordpartiklene er det rikelig med leire på letestedet. Tilgjengeligheten av leirpartikler på overflaten skyldes den rikelige ernæringen som tilføres. Torven og leirjorden er knapt tilstede. Den leire-type jorda er romslig i mellom, hvor vannet holdes tilbake.

datasett

Kaggle Link

Funksjonsutvinning er et av hovedtrinnene i å bygge en god dyplæringsmodell. Det er viktig å identifisere funksjoner som kan være nødvendige for å bygge maskinlæringsalgoritmene. Vi vil bruke Mahotas bibliotek for å trekke ut Haralick-funksjoner, som har romlig og teksturinformasjon for bildene.

Vi vil bruke skimage-biblioteket til å konvertere bilder til gråtoner og trekke ut Histogram of Gradient (HOG)-funksjoner som er nyttige for objektdeteksjon. Til slutt vil vi sette sammen verdiene til funksjonene til en matrise og senere bruke dem i maskinlæring og dyplæringsalgoritmer.

Funksjonsutvinning | Dyplæring i landbruket

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)

Maskinlæringsalgoritmer i jordklassifisering

La oss nå bygge en maskinlæringsmodell ved å bruke jordbildene vi fikk fra Kaggle.

Først vil vi importere alle bibliotekene og deretter bygge en funksjon som heter extract_features å trekke ut funksjoner fra bilder. Bildene blir så importert og behandlet, som inkluderer konvertering til gråtoner, og så får vi disse funksjonene. Deretter, etter at funksjoner er trukket ut for hvert bilde, kodes etiketter ved hjelp av Etikettkoder.

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)

UTGANG | Dyplæring i landbruket — UTGANG

Deep Neural Networks

Det fungerer basert på beregningsenheter og antall nevroner. Hvert nevron aksepterer innganger og gir utgang. Den brukes til å øke nøyaktigheten og gjøre bedre spådommer, mens maskinlæringsalgoritmer er avhengige av å tolke dataene, og beslutninger vil bli tatt basert på dem.

Les også: En introduksjonsguide til dyp læring og nevrale nettverk

La oss nå bygge modellen definert ved hjelp av Sequential API fra Keras. Denne modellen vil ha et Conv2D konvolusjonslag, MaxPooling2D, et flatende lag Flatten og tette lag Dense.

Til slutt er modellen kompilert ved hjelp av Adam optimizer og kategorisk kryssentropitap.

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)

Som du kan se, er den forutsagte klassen 0, som er Black Soil. Så vår modell klassifiserer jordtypen riktig.

Foreslått multi-stacking Ensemble Learning Model Architectures

De StackingClassifier initialiseres med baseClassifiers og en logistisk regresjon metaklassifiserer final_estimator. Dette kombinerer utdataene fra baseClassifiers for å lage en endelig prediksjon. Deretter, etter trening og forutsigelse, beregnes nøyaktigheten.

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)

konklusjonen

Jord er et viktig element for å gi en god avling. Det er viktig å vite hvilken jordtype som er nødvendig for å produsere den spesifikke avlingen. Så det blir viktig å klassifisere jordtypen. Siden manuell klassifisering av jordtypen er en tidkrevende oppgave, blir det derfor enkelt å bruke dyplæringsmodeller for å klassifisere dem. Det er mange maskinlæringsmodeller og dyplæringsmodeller for å implementere denne problemformuleringen. Valget av den beste avhenger av kvaliteten og mengden av dataene som finnes i datasettet og problemformuleringen for hånden. En annen måte å velge den beste algoritmen på er å evaluere hver. Vi kan gjøre det ved å måle nøyaktigheten, etter hvor mye de kan klassifisere jorda riktig. Til slutt implementerte vi en Multi-Stacking-ensemblemodell, og brukte flere modeller for å bygge den beste modellen.

Nøkkelfunksjoner

For effektivt avlingsvalg bør man forstå jorda fullstendig.
Dyplæring i landbruket er et kraftig verktøy, fra å forutsi plantesykdom til jordtyper og vannbehov.
Vi har gjort funksjonsekstraksjon for å få funksjoner fra jordbilder.
I denne bloggen utforsket vi maskinlærings- og dyplæringsmodeller for klassifisering av jord og en flerstablet ensemblemodell for forbedret nøyaktighet.