🤖 Pengenalan AI & Machine Learning

Apa itu AI, ML, dan Deep Learning — plus 3 paradigma belajar dan workflow lengkap.

📌 1. AI, ML, Deep Learning: Definisi Bertingkat

Artificial Intelligence (AI)
└── Machine Learning (ML)          ← sistem "belajar" dari data, bukan ditulis aturan manual
    └── Deep Learning (DL)         ← ML dengan neural network berlapis-lapis

Contoh konkret:
• AI manual      : if suhu > 28: nyalakan_ac()      ← aturan ditulis manusia
• ML             : model dilatih dari 10.000 data suhu + status AC ← aturan "ditemukan" dari data
• Deep Learning  : neural network 10 layer memprediksi beban listrik ← hierarki fitur otomatis

Intinya: ML = menemukan pola dari data. Daripada kita menulis ribuan aturan if-else, kita kasih data ke algoritma dan biarkan algoritma itu menemukan sendiri rumus/pola yang memetakan input → output.

💡 Di kuliah ini kita menulis algoritma ML-nya sendiri dengan Python murni (tanpa sklearn, tanpa numpy). Ini cara tercepat memahami apa yang sebenarnya terjadi "di dalam" setiap model.

📌 2. Tiga Paradigma Belajar

Paradigma	Data	Tujuan	Contoh
Supervised	Input + label jawaban	Prediksi label/nilai baru	Klasifikasi spam, prediksi harga
Unsupervised	Hanya input, tanpa label	Temukan struktur tersembunyi	Clustering pelanggan, deteksi anomali
Reinforcement	State + reward (hadiah/hukuman)	Belajar strategi/optimal action	Robot jalan, game AI, trading

Ada juga semi-supervised (sedikit label + banyak tanpa label) dan self-supervised (label dibuat dari data itu sendiri) — varian modern yang banyak dipakai di training model bahasa besar.

📌 3. Workflow Machine Learning

BISA MASALAH   : apa yang mau diprediksi? (klasifikasi / regresi / clustering?)
DATA          : kumpulkan data, pastikan cukup & relevan
EDA           : lihat statistik, grafik, korelasi, data rusak/hilang?
PREPROCESSING : bersihkan, normalisasi, encoding kategori
TRAIN         : bagi train/test, pilih model, latih
EVALUASI      : ukur dengan metrik yang tepat (bukan cuma accuracy!)
DEPLOY        : simpan model, serve via API, monitoring drift

⚠️ 80% waktu praktisi ML habis di langkah 2–4 (data), bukan di "model canggih".

📌 4. "Hello World" ML: Pipeline Lengkap dalam 1 Kode

Pipeline 6 langkah (data → split → train → predict → evaluate → deploy) untuk masalah klasifikasi sederhana. Jalankan dan perhatikan alurnya:

print("=== HELLO WORLD: PIPELINE ML LENGKAP ===\n")

# ── 1. DATA: 100 titik, 2 fitur, 2 kelas (label 0/1) ──
random_seed(42)
X, y = make_classification(100, n_features=2, sep=1.8)
plot_points(X, y, title="Langkah 1: Data (2 fitur, 2 kelas)")

# ── 2. SPLIT: 70% train, 30% test ──
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3)
print("\nLangkah 2: %d titik train, %d titik test" % (len(Xtr), len(Xte)))

# ── 3. TRAIN: logistic regression (disederhanakan) ──
w = [0.0, 0.0, 0.0]          # bobot: [bias, w1, w2]
Xb = add_bias(Xtr)           # tambah kolom 1 untuk bias
for epoch in range(200):
    for i in range(len(Xb)):
        p = sigmoid(dot(w, Xb[i]))          # probabilitas
        w = vec_sub(w, vec_scale(Xb[i], 0.5 * (p - ytr[i])))  # update

# ── 4. PREDICT: klasifikasi data test ──
pred = [1 if sigmoid(dot(w, [1.0] + x)) >= 0.5 else 0 for x in Xte]

# ── 5. EVALUATE ──
print("Langkah 5: accuracy = %.1f%%" % (accuracy(yte, pred) * 100))

# ── 6. DEPLOY (simulasi): "simpan" model ──
print("Langkah 6: model siap! bobot =", [round(v, 3) for v in w])
print("Artinya: pred = 1 jika  %.2f + %.2f*x1 + %.2f*x2 >= 0"
      % (-w[0], w[1], w[2]))

Output:

Coba ubah sep=1.8 menjadi sep=0.8 (kelas makin overlap) dan test_size=0.3 menjadi 0.5 — lihat akurasinya berubah.

📌 5. Kenapa Butuh ML? Batas Aturan Manual

Untuk pola sederhana, if-else cukup. Tapi coba aturan manual menghadapi data berbentuk "dua bulan" (non-linear):

print("=== ATURAN MANUAL vs DATA NON-LINEAR ===\n")
random_seed(7)
X, y = make_moons(80)
plot_points(X, y, title="Data 'moons': batasnya melengkung")

# Coba aturan manual paling masuk akal: belah di x = 0.5
pred_manual = [1 if p[0] > 0.5 else 0 for p in X]
print("\nAkurasi aturan 'x > 0.5 ?'      : %.1f%%" % (accuracy(y, pred_manual) * 100))

# Coba aturan lain: belah di y = 0
pred_manual2 = [1 if p[1] > 0 else 0 for p in X]
print("Akurasi aturan 'y > 0 ?'         : %.1f%%" % (accuracy(y, pred_manual2) * 100))

# Kesimpulan:
# - Pola melengkung TIDAK bisa diwakili garis lurus x=0.5 atau y=0
# - Butuh model yang BISA BELAJAR bentuk batasnya dari data
#  (di bab berikut: logistic regression, KNN, tree, neural network)

Output:

📌 6. Peta Keluarga Model (Akan Kita Bahas)

Keluarga	Model	Bab
Regresi	Linear Regression	4
Regresi	Logistic Regression	5
Instance-based / Geometri	K-Nearest Neighbors	6
	Decision Tree	7
	Support Vector Machine	9
Probabilistik	Naive Bayes	8
Clustering	K-Means	10
	Hierarchical + DBSCAN	11
	PCA (reduksi dimensi)	12
Neural Network	Perceptron & MLP (backprop)	13
Neural Network	CNN & RNN (konsep)	14
Ensemble	Random Forest, Gradient Boosting	15
Reinforcement	Q-Learning	16
NLP	BoW, TF-IDF, text classifier	17

🧠 Latihan

Di kode "Hello World", tambahkan metrik precision() dan recall() untuk kelas 1, lalu bandingkan dengan accuracy.
Ubah jumlah epoch dari 200 menjadi 20 dan 2000 — apa yang terjadi pada accuracy? Kapan training "cukup"?
Di contoh moons, coba aturan manual lain (mis. x + y > 0.5) — apakah bisa mencapai > 80%? Berapa batas terbaik yang bisa kamu capai dengan aturan garis lurus?
Jelaskan dengan kata-kirimumu sendiri perbedaan supervised dan unsupervised, masing-masing dengan 1 contoh aplikasi di dunia nyata.