Jordbruk och djupinlärning: Förbättring av jord- och grödor

Beskrivning

Jordbruk är mer än bara ett jobb för många indier; det är ett sätt att leva. Det är medlen genom vilka de försörjer sin försörjning och bidrar oerhört mycket till Indiens ekonomi. Bestämning av vilken typ av jord som har ler-, sand- och siltpartiklarna i respektive proportioner är viktigt för lämpligt val av gröda och för att identifiera ogräsets tillväxt. Upptäck potentialen med Deep Learning in Agriculture. Förstå vikten av jordtyper och ogräsdetektering för Indien.

Djup lärning är en framväxande teknik som är användbar inom alla områden. Deep learning har populärt tillämpats inom smart jordbruk över skalor för fältövervakning, fältdrift, robotteknik, förutsägelse av jord, vatten, klimatförhållanden och övervakning av land- och grödor på landskapsnivå. Vi kan mata bilden av jord till en djupinlärningsarkitektur, vägleda den att lära sig att upptäcka funktioner och sedan använda djupinlärningsarkitekturen för att klassificera jorden.

I den här bloggen kommer vi att diskutera markens betydelse i jordbruket. Vi kommer att klassificera jord med hjälp av maskininlärning och modeller för djupinlärning.

Inlärningsmål

• Du kommer att förstå hur viktig mark är i jordbruket.
• Du kommer att lära dig hur maskininlärningsalgoritmer kan klassificera jordtyper.
• Du kommer att implementera en modell för djupinlärning inom jordbruket för att klassificera jordtyper.
• Utforska konceptet med multi-stacking ensemble learning för att öka noggrannheten i våra förutsägelser.

Denna artikel publicerades som en del av Data Science Blogathon.

Markens roll i jordbruket

Organiskt material, mineraler, gaser, vätskor och andra ämnen som utsöndras från växter och djur bildar viktig jord, en grund för jordbruket. Grunden för jordbruket ligger i de gaser, mineraler, organiskt material och andra ämnen som kommer från växter och djur och bildar marksystemet.

Indiens ekonomi är helt beroende av jordbruk; jorden är viktig för grödorna, och den leder till utveckling av oönskade ogräs på grund av dess bördighet.

Fukt och temperatur är de fysiska variablerna som påverkar bildandet av porer och partiklar i jorden, vilket påverkar rottillväxt, vatteninfiltration och växternas uppkomsthastighet.

Men främst har jorden partiklar av sand och lera. Bland de vanligast tillgängliga jordpartiklarna finns det gott om lera på prospekteringsplatsen. Lerpartiklarnas tillgänglighet på ytan beror på den rikliga näringen som tillförs. Torven och lerjorden är knappast närvarande. Den lerliknande jorden är rymlig däremellan, där vattnet hålls kvar.

dataset

Kaggle Link

Funktionsextraktion är ett av huvudstegen för att bygga en bra modell för djupinlärning. Det är viktigt att identifiera funktioner som kan vara nödvändiga för att bygga maskininlärningsalgoritmerna. Vi kommer att använda Mahotas bibliotek för att extrahera Haralick-funktioner, som har rumslig information och texturinformation för bilderna.

Vi kommer att använda skimage-biblioteket för att konvertera bilder till gråskala och för att extrahera Histogram of Gradient (HOG) funktioner som är användbara för objektdetektering. Slutligen kommer vi att sammanfoga funktionernas värden till en array och senare använda dem i maskininlärning och djupinlärningsalgoritmer.

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)

Maskininlärningsalgoritmer i jordklassificering

Låt oss nu bygga en maskininlärningsmodell med hjälp av jordbilderna vi fick från Kaggle.

Först kommer vi att importera alla bibliotek och sedan bygga en funktion som heter extract_features för att extrahera funktioner från bilder. Bilderna importeras och bearbetas sedan, vilket inkluderar konvertering till gråskala, och sedan får vi dessa funktioner. Sedan, efter att funktioner har extraherats för varje bild, kodas etiketter med Etikettkodare.

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)

Djupa neurala nätverk

Det fungerar baserat på beräkningsenheter och antalet neuroner. Varje neuron accepterar ingångar och ger utdata. Det används för att öka noggrannheten och göra bättre förutsägelser, medan maskininlärningsalgoritmer förlitar sig på att tolka data och beslut kommer att fattas utifrån dem.

Läs också: En introduktionsguide till djupt lärande och neurala nätverk

Låt oss nu bygga modellen som definieras med Sequential API från Keras. Denna modell kommer att ha ett Conv2D faltningslager, MaxPooling2D, ett tillplattande lager Flatten och täta lager Dense.

Slutligen sammanställs modellen med hjälp av Adam optimerare och kategorisk korsentropiförlust.

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 är den förutsagda klassen 0, vilket är Black Soil. Så vår modell klassificerar typen av jord korrekt.

Föreslagen Multi-stacking Ensemble Learning Model Architectures

Smakämnen StackingClassifier initieras med baseClassifiers och en logistisk återgång meta-klassificerare final_estimator. Detta kombinerar utdata från baseClassifiers för att göra en slutlig förutsägelse. Sedan, efter träning och förutsägelse, beräknas noggrannheten.

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)

Slutsats

Jord är en viktig faktor för att ge en bra skörd. Att veta vilken jordtyp som är nödvändig för att producera den specifika grödan är viktigt. Så det blir viktigt att klassificera typen av jord. Eftersom manuell klassificering av jordtypen är en tidskrävande uppgift, blir det lätt att använda modeller för djupinlärning för att klassificera dem. Det finns många maskininlärningsmodeller och modeller för djupinlärning för att implementera denna problemformulering. Att välja den bästa beror på kvaliteten och mängden av data som finns i datamängden och den aktuella problemformuleringen. Ett annat sätt att välja den bästa algoritmen är att utvärdera var och en. Vi kan göra det genom att mäta noggrannheten, med hur mycket de kan klassificera jorden korrekt. Slutligen implementerade vi en Multi-Stacking-ensemblemodell, med hjälp av flera modeller för att bygga den bästa modellen.

Key Takeaways

• För ett effektivt val av grödor bör man förstå jorden helt.
• Deep learning inom jordbruket är ett kraftfullt verktyg, från att förutsäga växtsjukdomar till jordtyper och vattenbehov.
• Vi har gjort funktionsextraktion för att få funktioner från jordbilder.
• I den här bloggen utforskade vi modeller för maskininlärning och djupinlärning för att klassificera jord och en flerstaplad ensemblemodell för förbättrad noggrannhet.

Vanliga frågor

Medierna som visas i den här artikeln ägs inte av Analytics Vidhya och används efter författarens gottfinnande.

Relaterad

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://www.analyticsvidhya.com/blog/2024/01/deep-learning-in-agriculture-improving-soil-crop-yields/