Pertanian & Pembelajaran Mendalam: Meningkatkan Hasil Tanah & Tanaman

Pengantar

Pertanian bukan sekedar pekerjaan bagi banyak orang India; itu adalah cara hidup. Ini adalah sarana yang mereka gunakan untuk menunjang penghidupan mereka dan berkontribusi besar terhadap perekonomian India. Penentuan jenis tanah yang memiliki proporsi masing-masing partikel tanah liat, pasir, dan lanau penting untuk pemilihan tanaman yang sesuai dan mengidentifikasi pertumbuhan gulma. Temukan potensi Pembelajaran Mendalam di bidang Pertanian. Memahami pentingnya jenis tanah dan deteksi gulma bagi India.

Belajar mendalam adalah teknologi baru yang berguna dalam segala bidang. Pembelajaran mendalam telah populer diterapkan dalam pertanian cerdas dalam berbagai skala untuk pemantauan lapangan, operasi lapangan, robotika, prediksi tanah, air, kondisi iklim, dan pemantauan jenis lahan dan tanaman di tingkat lanskap. Kita dapat memasukkan foto tanah ke arsitektur pembelajaran mendalam, memandunya untuk belajar mendeteksi fitur, dan kemudian menggunakan arsitektur pembelajaran mendalam untuk mengklasifikasikan tanah.

Di blog ini kita akan membahas pentingnya tanah dalam pertanian. Kami akan mengklasifikasikan tanah menggunakan pembelajaran mesin dan model pembelajaran mendalam.

Tujuan Pembelajaran

• Anda akan memahami betapa pentingnya tanah dalam pertanian.
• Anda akan mempelajari bagaimana algoritme pembelajaran mesin dapat mengklasifikasikan jenis tanah.
• Anda akan menerapkan model pembelajaran mendalam di bidang pertanian untuk mengklasifikasikan jenis tanah.
• Jelajahi konsep pembelajaran ansambel multi-susun untuk meningkatkan akurasi prediksi kami.

Artikel ini diterbitkan sebagai bagian dari Blogathon Ilmu Data.

Peran Tanah dalam Pertanian

Bahan organik, mineral, gas, cairan, dan zat lain yang dikeluarkan dari tumbuhan dan hewan membentuk tanah yang penting, landasan bagi pertanian. Fondasi pertanian terletak pada gas, mineral, bahan organik, dan zat lain yang berasal dari tumbuhan dan hewan, yang membentuk sistem tanah.

Perekonomian India sepenuhnya bergantung pada pertanian; tanah penting bagi tanaman, dan hal ini menyebabkan berkembangnya gulma yang tidak diinginkan karena kesuburannya.

Kelembaban dan suhu merupakan variabel fisik yang mempengaruhi pembentukan pori-pori dan partikel dalam tanah, mempengaruhi pertumbuhan akar, infiltrasi air, dan kecepatan munculnya tanaman.

Namun sebagian besar tanahnya memiliki partikel pasir dan tanah liat. Di tengah banyaknya partikel tanah, tanah liat juga melimpah di lokasi eksplorasi. Ketersediaan partikel tanah liat di permukaan disebabkan oleh melimpahnya nutrisi yang diberikan. Gambut dan lempung hampir tidak ada. Tanah jenis tanah liat memiliki ruang yang luas di antaranya, sehingga air dapat tertahan.

Dataset

Tautan Kaggle

Ekstraksi fitur merupakan salah satu langkah utama dalam membangun model pembelajaran mendalam yang baik. Penting untuk mengidentifikasi fitur yang mungkin diperlukan untuk membangun algoritme pembelajaran mesin. Kami akan menggunakan Mahota perpustakaan untuk mengekstrak fitur Haralick, yang memiliki informasi spasial dan tekstur gambar.

Kami akan menggunakan perpustakaan skimage untuk mengonversi gambar menjadi skala abu-abu dan mengekstrak fitur Histogram of Gradient (HOG) yang berguna untuk deteksi objek. Terakhir, kami akan menggabungkan nilai fitur ke dalam array dan kemudian menggunakannya dalam pembelajaran mesin dan algoritma pembelajaran mendalam.

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)

Algoritma Pembelajaran Mesin dalam Klasifikasi Tanah

Sekarang, mari kita buat model pembelajaran mesin menggunakan gambar tanah yang kita dapatkan dari Kaggle.

Pertama, kita akan mengimpor semua perpustakaan dan kemudian membangun sebuah fungsi bernama ekstrak_fitur untuk mengekstrak fitur dari gambar. Gambar tersebut kemudian diimpor dan diproses, termasuk mengkonversi ke skala abu-abu, dan kemudian kami mendapatkan fitur-fitur ini. Kemudian, setelah fitur diekstraksi untuk setiap gambar, label dikodekan menggunakan Pengkode Label.

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)

Jaringan Neural Dalam

Ia bekerja berdasarkan unit komputasi dan jumlah neuron. Setiap neuron menerima masukan dan memberikan keluaran. Ini digunakan untuk meningkatkan akurasi dan membuat prediksi yang lebih baik, sementara algoritma pembelajaran mesin mengandalkan interpretasi data, dan keputusan akan dibuat berdasarkan data tersebut.

Juga Baca: Panduan Pengantar Pembelajaran Mendalam dan Jaringan Syaraf Tiruan

Sekarang, mari kita membangun model yang ditentukan menggunakan Sequential API dari Keras. Model ini akan memiliki lapisan konvolusi Conv2D, MaxPooling2D, lapisan perataan Ratakan, dan lapisan padat Padat.

Terakhir, model dikompilasi menggunakan Adam pengoptimal dan kerugian lintas entropi kategoris.

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)

Seperti yang Anda lihat, kelas yang diprediksi adalah 0, yaitu Tanah Hitam. Jadi, model kita mengklasifikasikan jenis tanah dengan benar.

Usulan Arsitektur Model Pembelajaran Ensemble Multi-susun

Grafik Pengklasifikasi Penumpukan diinisialisasi dengan baseClassifiers dan a regresi logistik pengklasifikasi meta penaksir_akhir. Ini menggabungkan keluaran baseClassifiers untuk membuat prediksi akhir. Kemudian, setelah pelatihan dan prediksi, akurasi dihitung.

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)

Kesimpulan

Tanah merupakan elemen penting dalam menghasilkan panen yang baik. Mengetahui jenis tanah yang diperlukan untuk menghasilkan tanaman tertentu adalah penting. Oleh karena itu, pengklasifikasian jenis tanah menjadi penting. Karena mengklasifikasikan jenis tanah secara manual adalah tugas yang memakan waktu, maka penggunaan model pembelajaran mendalam untuk mengklasifikasikannya menjadi mudah. Ada banyak model pembelajaran mesin dan model pembelajaran mendalam untuk mengimplementasikan rumusan masalah ini. Memilih yang terbaik bergantung pada kualitas dan jumlah data yang ada dalam kumpulan data dan rumusan masalah yang ada. Cara lain untuk memilih algoritma terbaik adalah dengan mengevaluasi masing-masing algoritma. Kita dapat melakukannya dengan mengukur keakuratannya, yaitu seberapa tepat mereka dapat mengklasifikasikan tanah. Terakhir, kami menerapkan model ansambel Multi-Stacking, menggunakan beberapa model untuk membangun model terbaik.

Pengambilan Kunci

• Untuk pemilihan tanaman yang efektif, seseorang harus memahami tanah sepenuhnya.
• Pembelajaran mendalam di bidang pertanian adalah alat yang ampuh, mulai dari memprediksi penyakit tanaman hingga jenis tanah dan kebutuhan air.
• Kami telah melakukan ekstraksi fitur untuk mendapatkan fitur dari citra tanah.
• Di blog ini, kami menjelajahi model pembelajaran mesin dan pembelajaran mendalam untuk mengklasifikasikan tanah dan model ansambel Multi-tumpukan untuk meningkatkan akurasi.

Tanya Jawab Umum (FAQ)

Media yang ditampilkan dalam artikel ini bukan milik Analytics Vidhya dan digunakan atas kebijaksanaan Penulis.

terkait

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• PlatoData.Jaringan Vertikal Generatif Ai. Berdayakan Diri Anda. Akses Di Sini.
• PlatoAiStream. Intelijen Web3. Pengetahuan Diperkuat. Akses Di Sini.
• PlatoESG. Karbon, teknologi bersih, energi, Lingkungan Hidup, Tenaga surya, Penanganan limbah. Akses Di Sini.
• PlatoHealth. Kecerdasan Uji Coba Biotek dan Klinis. Akses Di Sini.
• Sumber: https://www.analyticsvidhya.com/blog/2024/01/deep-learning-in-agriculture-improving-soil-crop-yields/