Rolnictwo i głębokie uczenie się: poprawa plonów gleby i upraw

Wprowadzenie

Dla wielu Hindusów rolnictwo to coś więcej niż tylko praca; to jest sposób życia. W ten sposób zapewniają sobie środki do życia i wnoszą ogromny wkład w gospodarkę Indii. Określenie rodzaju gleby zawierającej cząstki gliny, piasku i mułu w odpowiednich proporcjach jest ważne dla odpowiedniego doboru upraw i identyfikacji wzrostu chwastów. Odkryj potencjał głębokiego uczenia się w rolnictwie. Zrozum znaczenie rodzajów gleby i wykrywania chwastów dla Indii.

Głęboka nauka to nowa technologia, która jest pomocna w każdej dziedzinie. Uczenie głębokie jest powszechnie stosowane w inteligentnym rolnictwie na szeroką skalę do monitorowania pól, prowadzenia prac polowych, robotyki, przewidywania warunków glebowych, wodnych i klimatycznych oraz monitorowania gruntów i rodzajów upraw na poziomie krajobrazu. Możemy przekazać zdjęcie gleby architekturze głębokiego uczenia się, poprowadzić ją tak, aby nauczyła się wykrywać cechy, a następnie wykorzystać architekturę głębokiego uczenia się do sklasyfikowania gleby.

Na tym blogu omówimy znaczenie gleby w rolnictwie. Sklasyfikujemy glebę za pomocą modeli uczenia maszynowego i głębokiego uczenia się.

Cele kształcenia

• Zrozumiesz, jak ważna jest gleba w rolnictwie.
• Dowiesz się, jak algorytmy uczenia maszynowego mogą klasyfikować rodzaje gleby.
• Wdrożysz model głębokiego uczenia się w rolnictwie w celu klasyfikacji typów gleby.
• Zapoznaj się z koncepcją wieloukładowego uczenia się zespołowego, aby zwiększyć dokładność naszych przewidywań.

Ten artykuł został opublikowany jako część Blogathon nauki o danych.

Rola gleby w rolnictwie

Materia organiczna, minerały, gazy, ciecze i inne substancje wydalane przez rośliny i zwierzęta tworzą ważną glebę, stanowiącą podstawę rolnictwa. Podstawą rolnictwa są gazy, minerały, materia organiczna i inne substancje pochodzące z roślin i zwierząt, tworzące system glebowy.

Gospodarka Indii opiera się wyłącznie na rolnictwie; gleba jest ważna dla upraw, a ze względu na jej żyzność prowadzi do rozwoju niepożądanych chwastów.

Wilgoć i temperatura to zmienne fizyczne, które wpływają na powstawanie porów i cząstek w glebie, wpływając na wzrost korzeni, infiltrację wody i prędkość wschodów roślin.

Ale głównie gleba zawiera cząstki piasku i gliny. Wśród powszechnie dostępnych cząstek gleby w miejscu poszukiwań występuje duża ilość gliny. Dostępność cząstek gliny na powierzchni wynika z obfitego dostarczania składników odżywczych. Torf i glina są prawie nieobecne. Pomiędzy nimi znajduje się gleba gliniasta, w której zatrzymywana jest woda.

Dataset

Link do Kaggle'a

Ekstrakcja cech jest jednym z głównych kroków w budowaniu dobrego modelu głębokiego uczenia się. Ważne jest zidentyfikowanie cech, które mogą być niezbędne do zbudowania algorytmów uczenia maszynowego. Będziemy korzystać z Mahota bibliotekę do wyodrębniania funkcji Haralick, które zawierają informacje o przestrzeni i teksturze obrazów.

Użyjemy biblioteki skimage do konwersji obrazów do skali szarości i wyodrębnienia funkcji histogramu gradientu (HOG), które są przydatne do wykrywania obiektów. Na koniec połączymy wartości funkcji w tablicę, a później wykorzystamy je w algorytmach uczenia maszynowego i głębokiego uczenia się.

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)

Algorytmy uczenia maszynowego w klasyfikacji gleby

Teraz zbudujmy model uczenia maszynowego, korzystając z obrazów gleby, które otrzymaliśmy z Kaggle.

Najpierw zaimportujemy wszystkie biblioteki, a następnie zbudujemy funkcję o nazwie wyodrębnij funkcje aby wyodrębnić cechy z obrazów. Obrazy są następnie importowane i przetwarzane, co obejmuje konwersję do skali szarości, a następnie uzyskujemy te funkcje. Następnie, po wyodrębnieniu cech dla każdego obrazu, etykiety są kodowane przy użyciu Koder etykiet.

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)

Głębokie sieci neuronowe

Działa w oparciu o jednostki obliczeniowe i liczbę neuronów. Każdy neuron przyjmuje dane wejściowe i dostarcza dane wyjściowe. Służy do zwiększania dokładności i dokonywania lepszych przewidywań, natomiast algorytmy uczenia maszynowego polegają na interpretacji danych i na ich podstawie podejmowane będą decyzje.

Przeczytaj również: Przewodnik wprowadzający do głębokiego uczenia się i sieci neuronowych

Teraz zbudujmy model zdefiniowany przy użyciu Sequential API firmy Keras. Model ten będzie zawierał warstwę splotu Conv2D, MaxPooling2D, warstwę spłaszczającą Flatten i warstwy gęste Dense.

Na koniec model jest kompilowany przy użyciu metody Adam optymalizator i kategoryczna utrata entropii krzyżowej.

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)

Jak widać, przewidywaną klasą jest 0, czyli Black Soil. Zatem nasz model poprawnie klasyfikuje rodzaj gleby.

Proponowane architektury modeli uczenia się z wieloma stosami

Połączenia Klasyfikator układania jest inicjowany za pomocą baseClassifiers i a regresja logistyczna metaklasyfikator końcowy_estymator. Łączy to dane wyjściowe baseClassifiers w celu uzyskania ostatecznej prognozy. Następnie, po przeszkoleniu i przewidywaniu, obliczana jest dokładność.

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)

Wnioski

Gleba jest ważnym elementem zapewniającym dobre plony. Ważna jest wiedza, jaki rodzaj gleby jest niezbędny do uprawy danej rośliny. Dlatego ważna staje się klasyfikacja rodzaju gleby. Ponieważ ręczna klasyfikacja rodzaju gleby jest zadaniem czasochłonnym, wykorzystanie modeli głębokiego uczenia się do ich klasyfikacji staje się łatwe. Istnieje wiele modeli uczenia maszynowego i modeli głębokiego uczenia się, które umożliwiają wdrożenie tego opisu problemu. Wybór najlepszego zależy od jakości i ilości danych znajdujących się w zbiorze danych oraz od opisu problemu. Innym sposobem wyboru najlepszego algorytmu jest ocena każdego z nich. Możemy to zrobić mierząc dokładność, na ile potrafią poprawnie sklasyfikować glebę. Na koniec wdrożyliśmy model zespołowy Multi-Stacking, używając wielu modeli do zbudowania najlepszego modelu.

Na wynos

• Aby dokonać skutecznego doboru upraw, należy całkowicie poznać glebę.
• Głębokie uczenie się w rolnictwie to potężne narzędzie, umożliwiające przewidywanie chorób roślin po typ gleby i zapotrzebowanie na wodę.
• Dokonaliśmy ekstrakcji cech, aby uzyskać cechy z obrazów gleby.
• Na tym blogu zbadaliśmy modele uczenia maszynowego i głębokiego uczenia się do klasyfikacji gleby oraz model zespołowy z wieloma warstwami w celu zwiększenia dokładności.

Często Zadawane Pytania

Media pokazane w tym artykule nie są własnością Analytics Vidhya i są wykorzystywane według uznania Autora.

Związane z

• Dystrybucja treści i PR oparta na SEO. Uzyskaj wzmocnienie już dziś.
• PlatoData.Network Pionowe generatywne AI. Wzmocnij się. Dostęp tutaj.
• PlatoAiStream. Inteligencja Web3. Wiedza wzmocniona. Dostęp tutaj.
• PlatonESG. Węgiel Czysta technologia, Energia, Środowisko, Słoneczny, Gospodarowanie odpadami. Dostęp tutaj.
• Platon Zdrowie. Inteligencja w zakresie biotechnologii i badań klinicznych. Dostęp tutaj.
• Źródło: https://www.analyticsvidhya.com/blog/2024/01/deep-learning-in-agriculture-improving-soil-crop-yields/