Dokumentasi Sistem Rekomendasi Pupuk

🎯 Apa Tujuan Program Ini?

Sistem ini dirancang untuk memberikan Rekomendasi Pupuk Otomatis menggunakan metode Machine Learning (K-Means Clustering). Tujuannya adalah memberikan saran dosis pupuk yang akurat berdasarkan data nutrisi tanah yang diinput.

Catatan Desainer: Skrip tes.py sengaja dirancang agar transparan. Saat dijalankan, seluruh proses kalkulasi akan ditampilkan di terminal untuk memudahkan penelusuran dan pemahaman alur kerja sistem.

📊 Alur Kerja Sistem

🧪

Input Data

N, P, K tanah

→

⚖️

Normalisasi

StandardScaler

→

🎯

K-Means

Cari Cluster

→

💊

Rekomendasi

Dosis Pupuk

📥 Input

• N (Nitrogen) - t/ha
• P (Fosfor) - mg/kg
• K (Kalium) - mg/kg

⚙️ Proses

• Normalisasi Z-Score
• K-Means Clustering
• 3 Cluster optimal

📤 Output

• Urea - kg/ha
• SP-36 - kg/ha
• KCl - kg/ha

📦 Import Library

Bagian pertama program adalah mengimpor library yang diperlukan:

1  import pandas as pd
2  import numpy as np
3  from sklearn.cluster import KMeans
4  from sklearn.preprocessing import StandardScaler
5  import pickle

Baris 1: pandas

Library untuk manipulasi dan analisis data dalam bentuk tabel (DataFrame). Disingkat pd.

📌 Digunakan untuk: Membuat tabel data, menghitung statistik, filtering data

Baris 2: numpy

Library untuk komputasi numerik dan operasi array multidimensi. Disingkat np.

📌 Digunakan untuk: Operasi matematika, array, perhitungan jarak

Baris 3: KMeans

Algoritma clustering dari scikit-learn untuk mengelompokkan data menjadi K cluster.

📌 Digunakan untuk: Mengelompokkan data tanah ke dalam 3 cluster

Baris 4: StandardScaler

Tool untuk normalisasi data menggunakan metode Z-score (mean=0, std=1).

📌 Digunakan untuk: Menyamakan skala N, P, K sebelum clustering

Baris 5: pickle

Library untuk menyimpan dan memuat objek Python ke/dari file.

📌 Digunakan untuk: Menyimpan model yang sudah ditraining

🏷️ Fungsi Kategorisasi Nutrisi

Tiga fungsi ini mengkategorikan nilai nutrisi tanah menjadi: Rendah, Sedang, atau Tinggi

🔵 Fungsi categorize_N (Nitrogen)

 7  def categorize_N(n):
 8      if n < 5:
 9          return 'Rendah'
10      elif 5 <= n <= 6:
11          return 'Sedang'
12      else:
13          return 'Tinggi'

Rendah

N < 5 t/ha

Sedang

5 ≤ N ≤ 6 t/ha

Tinggi

N > 6 t/ha

🟠 Fungsi categorize_P (Fosfor)

15  def categorize_P(p):
16      if p < 200:
17          return 'Rendah'
18      elif 200 <= p <= 400:
19          return 'Sedang'
20      else:
21          return 'Tinggi'

Rendah

P < 200 mg/kg

Sedang

200 ≤ P ≤ 400 mg/kg

Tinggi

P > 400 mg/kg

🟣 Fungsi categorize_K (Kalium)

23  def categorize_K(k):
24      if k < 100:
25          return 'Rendah'
26      elif 100 <= k <= 200:
27          return 'Sedang'
28      else:
29          return 'Tinggi'

Rendah

K < 100 mg/kg

Sedang

100 ≤ K ≤ 200 mg/kg

Tinggi

K > 200 mg/kg

💡 Penjelasan Struktur Kode

def = Mendefinisikan fungsi baru

if...elif...else = Percabangan kondisi (jika...atau jika...selainnya)

return = Mengembalikan nilai hasil fungsi

📊 RULES_TABLE - Tabel Aturan Dosis Pupuk

RULES_TABLE adalah dictionary yang berisi 27 kombinasi aturan untuk menentukan dosis pupuk:

31  RULES_TABLE = {
32      ('Rendah', 'Rendah', 'Rendah'): {'Urea': 200, 'SP-36': 100, 'KCl': 100},
33      ('Rendah', 'Rendah', 'Sedang'): {'Urea': 200, 'SP-36': 100, 'KCl': 50},
    ... (total 27 kombinasi)
58      ('Tinggi', 'Tinggi', 'Tinggi'): {'Urea': 350, 'SP-36': 50, 'KCl': 50}
59  }

🧮 Logika 27 Kombinasi

N: 3 kategori × P: 3 kategori × K: 3 kategori = 27 Rules

📋 Contoh Beberapa Aturan:

Kategori (N, P, K)	Urea	SP-36	KCl	Interpretasi
Rendah, Rendah, Rendah	200	100	100	Tanah sangat miskin → butuh pupuk maksimal
Sedang, Sedang, Sedang	275	75	50	Tanah cukup → dosis seimbang
Tinggi, Tinggi, Tinggi	350	50	50	Tanah subur → N tinggi, P & K minimal

📐 Nilai Representatif Kategori

Dictionary ini menyimpan nilai numerik yang mewakili setiap kategori untuk membuat data training:

61  N_VALUES = {
62      'Rendah': 3.5,   # Nilai tengah range rendah (0-5)
63      'Sedang': 5.5,   # Nilai tengah range sedang (5-6)
64      'Tinggi': 7.0    # Nilai representatif tinggi (>6)
65  }
66
67  P_VALUES = {
68      'Rendah': 100,   # Nilai tengah range rendah (0-200)
69      'Sedang': 300,   # Nilai tengah range sedang (200-400)
70      'Tinggi': 500    # Nilai representatif tinggi (>400)
71  }
72
73  K_VALUES = {
74      'Rendah': 50,    # Nilai tengah range rendah (0-100)
75      'Sedang': 150,   # Nilai tengah range sedang (100-200)
76      'Tinggi': 250    # Nilai representatif tinggi (>200)
77  }

💡 Mengapa Perlu Nilai Representatif?

Algoritma K-Means membutuhkan data numerik. Karena kita punya 27 aturan berbasis kategori, kita perlu mengkonversi kategori menjadi angka. Nilai-nilai ini dipilih sebagai titik tengah dari setiap range kategori.

🔄 Loop Pembuatan Data Training

95  training_data = []  # List kosong untuk menyimpan data
96  rule_number = 1      # Counter nomor rule
97
98  for n_cat in ['Rendah', 'Sedang', 'Tinggi']:
99      for p_cat in ['Rendah', 'Sedang', 'Tinggi']:
100         for k_cat in ['Rendah', 'Sedang', 'Tinggi']:
101             key = (n_cat, p_cat, k_cat)  # Buat tuple key
102             doses = RULES_TABLE[key]      # Ambil dosis dari rules
103
104             training_data.append({
105                 'No': rule_number,
106                 'N': N_VALUES[n_cat],    # Konversi ke angka
107                 'P': P_VALUES[p_cat],
108                 'K': K_VALUES[k_cat],
109                 'N_Cat': n_cat,
110                 'P_Cat': p_cat,
111                 'K_Cat': k_cat,
112                 'Urea': doses['Urea'],
113                 'SP-36': doses['SP-36'],
114                 'KCl': doses['KCl']
115             })
116             rule_number += 1
117
118 df = pd.DataFrame(training_data)  # Konversi ke DataFrame

🔁 Nested Loop (3 level)

3 loop bersarang menghasilkan semua kombinasi:
Loop 1: N (3 nilai) × Loop 2: P (3 nilai) × Loop 3: K (3 nilai) = 27 kombinasi

📊 Hasil DataFrame

DataFrame dengan 27 baris dan 10 kolom: No, N, P, K, N_Cat, P_Cat, K_Cat, Urea, SP-36, KCl

⚖️ Normalisasi Data dengan StandardScaler

❓ Mengapa Perlu Normalisasi?

Tanpa normalisasi, fitur dengan skala besar (P: 100-500) akan mendominasi perhitungan jarak dibanding fitur skala kecil (N: 3.5-7). Normalisasi membuat semua fitur memiliki kontribusi yang setara.

130 X = df[['N', 'P', 'K']].values  # Ambil kolom N,P,K sebagai array
131
132 # Buat objek StandardScaler
133 scaler = StandardScaler()
134
135 # fit_transform: hitung mean & std, lalu transformasi
136 X_scaled = scaler.fit_transform(X)

📐 Rumus Z-Score Normalization

X_scaled = (X - μ) / σ

X

Nilai asli

μ (mu)

Mean (rata-rata)

σ (sigma)

Standard Deviation

X_scaled

Nilai ternormalisasi

🧮 Contoh Perhitungan Manual

Untuk data pertama: N=3.5, P=100, K=50

Fitur	Nilai (X)	Mean (μ)	Std (σ)	Perhitungan	Hasil
N	3.5	5.33	1.44	(3.5 - 5.33) / 1.44	-1.27
P	100	300	163.30	(100 - 300) / 163.30	-1.22
K	50	150	81.65	(50 - 150) / 81.65	-1.22

Hasil: Data [3.5, 100, 50] menjadi [-1.27, -1.22, -1.22] setelah normalisasi.
Nilai negatif berarti di bawah rata-rata, positif berarti di atas rata-rata.

🎯 Algoritma K-Means Clustering

🤔 Apa itu K-Means?

K-Means adalah algoritma yang mengelompokkan data menjadi K cluster berdasarkan kemiripan. Data yang mirip akan masuk ke cluster yang sama, data yang berbeda akan masuk ke cluster berbeda.

160 kmeans = KMeans(
161     n_clusters=3,        # Jumlah cluster yang diinginkan
162     random_state=42,     # Seed untuk reproducibility
163     n_init=10,           # Jumlah inisialisasi berbeda
164     max_iter=300         # Maksimum iterasi per inisialisasi
165 )
166
167 kmeans.fit(X_scaled)   # Training model dengan data ternormalisasi
168 labels = kmeans.labels_  # Ambil label cluster untuk setiap data

n_clusters = 3

Membagi data menjadi 3 kelompok (cluster). Angka 3 dipilih karena ada 3 tingkat kesuburan umum.

random_state = 42

Angka seed agar hasil selalu sama setiap kali dijalankan (reproducible).

n_init = 10

Algoritma dijalankan 10x dengan titik awal berbeda, hasil terbaik yang diambil.

max_iter = 300

Maksimum 300 iterasi untuk menemukan centroid optimal.

⚙️ Cara Kerja K-Means

1

Inisialisasi Centroid

Pilih 3 titik acak sebagai pusat cluster awal (centroid).

2

Assign Data ke Cluster

Hitung jarak setiap data ke semua centroid. Masukkan data ke cluster dengan centroid terdekat.

3

Update Centroid

Hitung ulang posisi centroid = rata-rata semua data dalam cluster tersebut.

4

Ulangi

Ulangi langkah 2-3 sampai centroid tidak berubah atau mencapai max_iter.

📊 Perhitungan Dosis per Cluster

200 df['Cluster'] = labels  # Tambah kolom cluster ke DataFrame
201
202 cluster_avg_doses = {}
203
204 for cluster_id in range(3):
205     # Filter data yang masuk cluster ini
206     cluster_data = df[df['Cluster'] == cluster_id]
207
208     # Hitung rata-rata dosis untuk cluster ini
209     avg_urea = cluster_data['Urea'].mean()
210     avg_sp36 = cluster_data['SP-36'].mean()
211     avg_kcl = cluster_data['KCl'].mean()
212
213     # Simpan ke dictionary
214     cluster_avg_doses[cluster_id] = {
215         'Urea': round(avg_urea, 2),
216         'SP-36': round(avg_sp36, 2),
217         'KCl': round(avg_kcl, 2)
218     }

💡 Logika Perhitungan

Setiap cluster berisi beberapa data dengan dosis pupuk berbeda. Rekomendasi dosis untuk cluster tersebut adalah rata-rata dari semua dosis data di dalamnya.

🔮 Proses Prediksi Data Baru

Ketika ada data pengukuran tanah baru, sistem akan memprediksi rekomendasi pupuk melalui langkah-langkah berikut:

250 # Contoh data baru dari pengukuran lapangan
251 new_test_data = np.array([[6.2, 95, 210]])
252
253 # LANGKAH 1: Normalisasi data baru
254 new_test_scaled = scaler.transform(new_test_data)
255
256 # LANGKAH 2: Prediksi cluster
257 new_predicted_cluster = kmeans.predict(new_test_scaled)[0]
258
259 # LANGKAH 3: Ambil rekomendasi dosis
260 new_doses = cluster_avg_doses[new_predicted_cluster]

📥 LANGKAH 1: Input Data Baru

new_test_data = np.array([[6.2, 95, 210]])

Data dari sensor/pengukuran lapangan:

N = 6.2

t/ha → Tinggi

P = 95

mg/kg → Rendah

K = 210

mg/kg → Tinggi

⚖️ LANGKAH 2: Normalisasi

new_test_scaled = scaler.transform(new_test_data)

Transformasi menggunakan mean & std dari data training:

N_scaled = (6.2 - 5.33) / 1.44 = 0.60

P_scaled = (95 - 300) / 163.30 = -1.26

K_scaled = (210 - 150) / 81.65 = 0.73

🎯 LANGKAH 3: Prediksi Cluster

predicted_cluster = kmeans.predict(new_test_scaled)[0]

Hitung jarak ke setiap centroid, pilih yang terdekat:

Jarak ke Cluster 0: 1.85

Jarak ke Cluster 1: 2.43

Jarak ke Cluster 2: 0.92 ✓ Terdekat

→ Hasil: Cluster 2

💊 LANGKAH 4: Ambil Rekomendasi

doses = cluster_avg_doses[predicted_cluster]

Rekomendasi dosis pupuk dari rata-rata Cluster 2:

🧪

Urea

350 kg/ha

🧫

SP-36

100 kg/ha

⚗️

KCl

50 kg/ha

📐 Rumus Perhitungan Jarak (Euclidean Distance)

d = √[(x₁-c₁)² + (x₂-c₂)² + (x₃-c₃)²]

d = jarak dari data ke centroid

x₁, x₂, x₃ = nilai N, P, K data (ternormalisasi)

c₁, c₂, c₃ = nilai N, P, K centroid (ternormalisasi)

🧮 Contoh Perhitungan:

Data: [0.60, -1.26, 0.73]
Centroid Cluster 2: [0.45, -1.10, 0.55]

d = √[(0.60-0.45)² + (-1.26-(-1.10))² + (0.73-0.55)²]
d = √[0.0225 + 0.0256 + 0.0324]
d = √0.0805
d = 0.28

💾 Menyimpan & Menggunakan Kembali Model

⭐ Menjadikan Model Siap Pakai

Agar sistem ini praktis dan cepat saat digunakan, proses training yang memakan waktu tidak perlu diulang setiap saat. Oleh karena itu, model yang sudah final akan disimpan ke dalam file. Proses ini memungkinkan model untuk dimuat kembali secara instan di aplikasi manapun. Dua file penting yang akan disimpan adalah model K-Means dan konfigurasi Scaler untuk normalisasi.

Bagian 1: Menyimpan Model ke File

Setelah model dilatih (`kmeans.fit()`), kita gunakan library `pickle` untuk menyimpannya ke dalam file. File ini biasanya berekstensi `.pkl`.

# --- Tambahkan kode ini di akhir skrip tes.py ---
import pickle

# ... (setelah baris kmeans.fit(X_scaled)) ...

# Menyimpan model K-Means yang sudah dilatih
FILENAME_MODEL = 'kmeans_model.pkl'
with open(FILENAME_MODEL, 'wb') as f:
    pickle.dump(kmeans, f)

# Menyimpan objek scaler
FILENAME_SCALER = 'scaler.pkl'
with open(FILENAME_SCALER, 'wb') as f:
    pickle.dump(scaler, f)

print(f"Model berhasil disimpan ke {FILENAME_MODEL}")
print(f"Scaler berhasil disimpan ke {FILENAME_SCALER}")

Penjelasan Kode

'wb' singkatan dari "write binary", mode yang dibutuhkan untuk menulis file pickle.
pickle.dump() adalah fungsi untuk "membuang" atau menulis objek Python ke dalam file.

Bagian 2: Memuat Model untuk Prediksi

Setelah model disimpan, ia siap digunakan di aplikasi lain (misalnya, dihubungkan ke website atau API). Contoh berikut menunjukkan cara membuat skrip prediksi yang ringkas tanpa perlu data atau proses training lagi.

File ini bisa diberi nama app_prediksi.py dan ditempatkan di folder yang sama dengan file model (.pkl) Anda.

import pickle
import numpy as np

# --- Muat model dan scaler dari file ---
try:
    with open('kmeans_model.pkl', 'rb') as f:
        kmeans_model = pickle.load(f)
    with open('scaler.pkl', 'rb') as f:
        scaler = pickle.load(f)
except FileNotFoundError:
    print("Error: File model tidak ditemukan. Jalankan skrip training terlebih dahulu.")
    exit()


# Data baru dari sensor (contoh)
new_data = np.array([[6.2, 95, 210]])

# LANGKAH 1: Normalisasi data menggunakan scaler yang sudah dimuat
new_data_scaled = scaler.transform(new_data)

# LANGKAH 2: Lakukan prediksi menggunakan model yang sudah dimuat
predicted_cluster = kmeans_model.predict(new_data_scaled)[0]

print(f"Data Input: {new_data[0]}")
print(f"Hasil Prediksi: Masuk ke Cluster {predicted_cluster}")

# Di sini Anda bisa menambahkan logika untuk memberikan rekomendasi dosis
# berdasarkan cluster yang diprediksi.

Penjelasan Kode

'rb' singkatan dari "read binary".
pickle.load() adalah fungsi untuk memuat objek dari file.
Skrip ini jauh lebih cepat karena tidak ada proses training, hanya memuat dan memprediksi.

📈 Visualisasi Hasil Clustering

Melihat data dalam bentuk tabel dan angka memang akurat, tetapi grafik dapat memberikan pemahaman intuitif dalam sekejap. Grafik di bawah ini adalah visualisasi 3D dari 27 data aturan kita, diwarnai berdasarkan cluster yang ditemukan oleh K-Means.

💡 Menghasilkan Grafik

Untuk membuat visualisasi ini, tambahkan dan jalankan kode Python berikut pada skrip tes.py. Setelah dieksekusi, sebuah file gambar bernama cluster_visualization.png akan dibuat di folder proyek Anda.

# Pastikan Anda sudah menginstal matplotlib dan seaborn:
# pip install matplotlib seaborn

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# ... (tambahkan kode ini di akhir skrip tes.py) ...

fig = plt.figure(figsize=(12, 10))
ax = fig.add_subplot(111, projection='3d')

# Scatter plot untuk setiap titik data
scatter = ax.scatter(df['N'], df['P'], df['K'], c=labels, cmap='viridis', s=60, alpha=0.8)

# Plot centroids (pusat cluster)
ax.scatter(centers_original[:, 0], centers_original[:, 1], centers_original[:, 2], c='red', s=250, marker='X', label='Centroids')

ax.set_title('Visualisasi 3D Hasil K-Means Clustering', fontsize=16)
ax.set_xlabel('Fitur N (t/ha)')
ax.set_ylabel('Fitur P (mg/kg)')
ax.set_zlabel('Fitur K (mg/kg)')
ax.legend()

# Simpan gambar
plt.savefig('cluster_visualization.png', dpi=150)
print("\nVisualisasi berhasil disimpan ke file: cluster_visualization.png")

Hasil Visualisasi

🔍 Membaca Grafik

Grafik ini memetakan setiap data aturan ke dalam ruang 3D. Berikut adalah cara membacanya:

Setiap titik berwarna adalah representasi dari satu aturan data berdasarkan kandungan N, P, dan K-nya.
Warna yang sama menandakan bahwa K-Means mengelompokkan titik-titik tersebut ke dalam satu cluster yang sama.
Tanda silang merah (X) yang besar adalah Centroid, atau titik pusat yang dihitung untuk setiap cluster.
Anda bisa melihat bagaimana titik-titik dengan warna serupa cenderung menggerombol. Ini adalah bukti visual bahwa model berhasil menemukan pola dan kemiripan dalam data, memisahkan kondisi tanah yang berbeda-beda secara efektif.