Robie: ←Membuat halaman berisi '= Roadmap Belajar Machine Learning dengan Python = Panduan ini disusun untuk pemula yang ingin memahami cara kerja machine learning (ML) secara sistematis menggunakan Python. Setiap fase dibangun di atas fase sebelumnya, jadi ikuti urutannya dan jangan terburu-buru melompat ke fase berikutnya sebelum fondasi benar-benar kuat. ---- == Fase 1 — Fondasi Python & Matematika == '''Estimasi waktu: 4–6 minggu''' Ini adalah fase yang paling sering dilewati pemula...'

2026-05-22T08:48:18Z

←Membuat halaman berisi '= Roadmap Belajar Machine Learning dengan Python = Panduan ini disusun untuk pemula yang ingin memahami cara kerja machine learning (ML) secara sistematis menggunakan Python. Setiap fase dibangun di atas fase sebelumnya, jadi ikuti urutannya dan jangan terburu-buru melompat ke fase berikutnya sebelum fondasi benar-benar kuat. ---- == Fase 1 — Fondasi Python & Matematika == '''Estimasi waktu: 4–6 minggu''' Ini adalah fase yang paling sering dilewati pemula...'

Halaman baru

= Roadmap Belajar Machine Learning dengan Python =

Panduan ini disusun untuk pemula yang ingin memahami cara kerja machine learning (ML) secara sistematis menggunakan Python. Setiap fase dibangun di atas fase sebelumnya, jadi ikuti urutannya dan jangan terburu-buru melompat ke fase berikutnya sebelum fondasi benar-benar kuat.

----

== Fase 1 — Fondasi Python & Matematika ==
'''Estimasi waktu: 4–6 minggu'''

Ini adalah fase yang paling sering dilewati pemula, dan paling sering menyebabkan mereka mandek di tengah jalan. Matematika bukan halangan — kamu tidak perlu menjadi ahli, tapi kamu perlu cukup paham untuk mengerti ''mengapa'' sebuah algoritma bekerja seperti itu.

=== 1.1 Python Dasar ===

Python adalah bahasa utama ekosistem ML. Sebelum menyentuh library apapun, pastikan kamu paham konsep berikut:

* Tipe data: integer, float, string, boolean
* Struktur data: list, tuple, dictionary, set
* Kontrol alur: if/else, for loop, while loop
* Fungsi: definisi, parameter, return value
* Object-Oriented Programming (OOP): class, objek, atribut, method
* Manajemen paket: pip install, virtual environment

'''Kenapa ini penting?'''
Hampir semua library ML (NumPy, Pandas, Scikit-learn) dibangun di atas konsep OOP Python. Kalau kamu tidak paham cara kerja objek dan method, kamu hanya akan copy-paste kode tanpa benar-benar mengerti apa yang terjadi.

'''Contoh kasus sederhana:'''
<syntaxhighlight lang="python">
# Kamu punya data nilai ujian 10 siswa
nilai = [78, 85, 90, 62, 74, 88, 95, 55, 80, 70]

# Hitung rata-rata manual pakai Python dasar
def hitung_rata_rata(data):
return sum(data) / len(data)

rata = hitung_rata_rata(nilai)
print(f"Rata-rata nilai: {rata}") # Output: 77.7

# Cari siswa yang nilainya di atas rata-rata
lulus = [n for n in nilai if n > rata]
print(f"Nilai di atas rata-rata: {lulus}")
</syntaxhighlight>

----

=== 1.2 Matematika untuk ML ===

Tiga pilar matematika yang wajib dikuasai:

==== Aljabar Linear ====
ML bekerja dengan data dalam bentuk angka yang direpresentasikan sebagai vektor dan matriks. Hampir semua perhitungan internal model ML adalah operasi matriks.

Yang perlu dipahami:
* Vektor dan operasinya (penjumlahan, dot product)
* Matriks dan operasinya (perkalian, transpose, invers)
* Nilai eigen (eigenvalue/eigenvector) — penting untuk PCA

'''Contoh kasus:''' Bayangkan kamu punya 1000 pelanggan, masing-masing dengan 50 data (usia, pendapatan, dll). Data ini adalah matriks berukuran 1000×50. Setiap operasi model ML pada dasarnya adalah manipulasi matriks ini.

==== Kalkulus (Dasar) ====
Digunakan saat model "belajar" — yaitu proses optimasi untuk meminimalkan error.

Yang perlu dipahami:
* Turunan (derivative) — konsep perubahan
* Gradient — arah turunan di ruang multidimensi
* Chain rule — dasar dari algoritma backpropagation di neural network

'''Intuisi sederhana:''' Bayangkan kamu berdiri di pegunungan berkabut dan ingin turun ke lembah paling rendah. Kamu meraba tanah di sekitarmu untuk tahu ke arah mana tanah menurun — itulah yang dilakukan gradient descent.

==== Statistik & Probabilitas ====
ML pada dasarnya adalah statistik yang dikomputasi. Kamu perlu memahami:

* Mean, median, modus, standar deviasi
* Distribusi data (normal, binomial)
* Korelasi dan kovarians
* Probabilitas dasar dan Teorema Bayes

'''Contoh kasus:'''
<syntaxhighlight lang="python">
import statistics

nilai = [78, 85, 90, 62, 74, 88, 95, 55, 80, 70]

print(f"Rata-rata : {statistics.mean(nilai)}")
print(f"Median : {statistics.median(nilai)}")
print(f"Std dev : {statistics.stdev(nilai):.2f}")

# Dari sini kamu bisa tahu: apakah data menyebar merata?
# Apakah ada nilai ekstrem (outlier)?
</syntaxhighlight>

----

=== 1.3 NumPy & Pandas ===

Ini adalah dua library paling fundamental dalam ekosistem data Python.

'''NumPy''' — untuk komputasi numerik dan operasi array/matriks yang cepat.

'''Pandas''' — untuk manipulasi data tabular (seperti Excel, tapi jauh lebih powerful).

'''Kenapa ini penting?'''
Semua data nyata (file CSV, database, API) harus dibersihkan dan diformat sebelum bisa dimasukkan ke model. Pandas adalah alat utamanya. NumPy adalah "mesin" di balik hampir semua library ML.

'''Contoh kasus sederhana:'''
<syntaxhighlight lang="python">
import numpy as np
import pandas as pd

# Simulasi data pelanggan toko
data = {
'nama' : ['Andi', 'Budi', 'Citra', 'Dian', 'Eka'],
'usia' : [25, 34, 28, 45, 31],
'pengeluaran': [150000, 320000, 210000, None, 280000]
}

df = pd.DataFrame(data)

# Lihat data
print(df.head())

# Isi nilai kosong dengan rata-rata
df['pengeluaran'].fillna(df['pengeluaran'].mean(), inplace=True)

# Hitung statistik dasar
print(df['pengeluaran'].describe())

# Operasi NumPy: normalisasi nilai ke skala 0-1
arr = np.array(df['pengeluaran'])
normalized = (arr - arr.min()) / (arr.max() - arr.min())
print(f"Nilai ternormalisasi: {normalized}")
</syntaxhighlight>

----

== Fase 2 — Data & Visualisasi ==
'''Estimasi waktu: 3–4 minggu'''

Di dunia nyata, 70–80% waktu seorang data scientist habis di fase ini. Data jarang sekali datang dalam kondisi bersih dan siap pakai.

=== 2.1 Exploratory Data Analysis (EDA) ===

EDA adalah proses "berkenalan" dengan data sebelum membangun model. Tujuannya adalah memahami pola, distribusi, hubungan antar variabel, dan masalah dalam data.

Yang harus dilakukan saat EDA:
* Cek ukuran data (jumlah baris dan kolom)
* Cek tipe data tiap kolom
* Temukan nilai yang hilang (missing values)
* Temukan nilai ekstrem (outlier)
* Pahami distribusi setiap fitur
* Cari korelasi antar fitur

'''Contoh kasus — prediksi harga rumah:'''
<syntaxhighlight lang="python">
import pandas as pd

df = pd.read_csv('harga_rumah.csv')

# Langkah 1: gambaran umum
print(df.shape) # misal: (1000, 8) = 1000 rumah, 8 fitur
print(df.info()) # tipe data dan jumlah non-null
print(df.describe()) # statistik dasar tiap kolom

# Langkah 2: cek missing values
print(df.isnull().sum())

# Langkah 3: cek distribusi harga
print(df['harga'].skew()) # positif = data condong ke kanan (ada rumah sangat mahal)
</syntaxhighlight>

----

=== 2.2 Visualisasi Data ===

Visualisasi membantu kamu melihat pola yang tidak terlihat dari angka mentah. Dua library utama: '''Matplotlib''' (fleksibel, level rendah) dan '''Seaborn''' (lebih mudah untuk statistik).

'''Kapan pakai jenis visualisasi apa:'''
* '''Histogram''' — distribusi satu variabel numerik
* '''Boxplot''' — melihat outlier dan sebaran data
* '''Scatter plot''' — hubungan antara dua variabel numerik
* '''Heatmap korelasi''' — melihat hubungan semua pasangan variabel sekaligus
* '''Bar chart''' — membandingkan kategori

'''Contoh kasus:'''
<syntaxhighlight lang="python">
import matplotlib.pyplot as plt
import seaborn as sns

# Heatmap korelasi — sangat berguna sebelum memilih fitur model
plt.figure(figsize=(10, 8))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm', fmt='.2f')
plt.title('Korelasi Antar Fitur')
plt.show()

# Dari heatmap ini kamu bisa tahu:
# fitur mana yang paling berkorelasi dengan 'harga' (target)
# fitur mana yang saling berkorelasi satu sama lain (multikolinearitas)
</syntaxhighlight>

----

=== 2.3 Feature Engineering ===

Feature engineering adalah seni mengubah data mentah menjadi representasi yang lebih bermakna untuk model. Ini adalah salah satu skill yang paling membedakan praktisi ML yang biasa dengan yang mahir.

Teknik-teknik utama:

* '''Encoding''' — mengubah kategori teks menjadi angka (Label Encoding, One-Hot Encoding)
* '''Normalisasi/Standarisasi''' — menyamakan skala antar fitur
* '''Handling missing values''' — isi dengan mean, median, modus, atau hapus
* '''Membuat fitur baru''' — kombinasikan fitur yang ada untuk menghasilkan informasi baru

'''Kenapa ini penting?'''
Model ML hanya bisa memproses angka. Teks seperti "Laki-laki"/"Perempuan" atau "Jakarta"/"Surabaya" harus dikonversi dulu. Selain itu, fitur dengan skala sangat berbeda (contoh: usia 25 vs pendapatan 5.000.000) bisa membuat model bias.

'''Contoh kasus:'''
<syntaxhighlight lang="python">
from sklearn.preprocessing import LabelEncoder, StandardScaler
import pandas as pd

df = pd.DataFrame({
'kota' : ['Jakarta', 'Surabaya', 'Bandung', 'Jakarta', 'Surabaya'],
'usia' : [25, 34, 28, 45, 31],
'pendapatan' : [3500000, 7200000, 4800000, 9000000, 5500000],
'beli' : ['Ya', 'Tidak', 'Ya', 'Ya', 'Tidak']
})

# One-Hot Encoding untuk kolom kota (lebih dari 2 kategori)
df = pd.get_dummies(df, columns=['kota'])

# Label Encoding untuk target biner
le = LabelEncoder()
df['beli'] = le.fit_transform(df['beli']) # Ya=1, Tidak=0

# Standarisasi usia dan pendapatan agar skalanya sama
scaler = StandardScaler()
df[['usia', 'pendapatan']] = scaler.fit_transform(df[['usia', 'pendapatan']])

print(df.head())
</syntaxhighlight>

----

== Fase 3 — Algoritma Machine Learning ==
'''Estimasi waktu: 6–8 minggu'''

Ini adalah inti dari seluruh perjalanan. Di fase ini kamu belajar berbagai algoritma ML, kapan menggunakannya, dan bagaimana mengevaluasi hasilnya. Library utama yang digunakan adalah '''Scikit-learn'''.

=== 3.1 Supervised Learning ===

Model dilatih menggunakan data yang sudah berlabel — artinya, kita tahu jawaban yang benar. Dibagi menjadi dua tugas:

* '''Regresi''' — memprediksi nilai kontinu (harga rumah, suhu, pendapatan)
* '''Klasifikasi''' — memprediksi kategori (spam/bukan spam, sakit/sehat, lulus/tidak)

Algoritma yang wajib dipelajari:
* Linear/Logistic Regression — paling sederhana, bagus untuk baseline
* K-Nearest Neighbors (KNN) — klasifikasi berdasarkan kedekatan
* Decision Tree — mudah diinterpretasi, visualisasi seperti pohon keputusan
* Random Forest — ensemble dari banyak Decision Tree, lebih akurat
* Support Vector Machine (SVM) — efektif untuk data berdimensi tinggi
* Gradient Boosting (XGBoost, LightGBM) — sering menang di Kaggle

'''Contoh kasus — prediksi apakah nasabah akan gagal bayar kredit:'''
<syntaxhighlight lang="python">
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import pandas as pd

# Asumsikan df sudah bersih dari Fase 2
X = df.drop('gagal_bayar', axis=1) # fitur
y = df['gagal_bayar'] # target (1=gagal, 0=aman)

# Bagi data: 80% latih, 20% uji
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)

# Latih model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Evaluasi
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))

# Lihat fitur mana yang paling berpengaruh
feat_importance = pd.Series(
model.feature_importances_, index=X.columns
).sort_values(ascending=False)
print(feat_importance.head(5))
</syntaxhighlight>

----

=== 3.2 Unsupervised Learning ===

Model bekerja pada data '''tanpa label'''. Tugasnya bukan memprediksi, tapi menemukan pola tersembunyi.

Algoritma utama:
* '''K-Means Clustering''' — mengelompokkan data ke dalam K kelompok
* '''DBSCAN''' — clustering berdasarkan kepadatan, bisa mendeteksi outlier
* '''PCA (Principal Component Analysis)''' — mereduksi dimensi data tanpa terlalu banyak kehilangan informasi

'''Contoh kasus — segmentasi pelanggan toko online:'''
<syntaxhighlight lang="python">
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import pandas as pd

# Data pelanggan: total transaksi dan rata-rata nilai transaksi
df = pd.DataFrame({
'jumlah_transaksi' : [5, 23, 2, 18, 7, 30, 1, 15, 25, 3],
'rata_nilai_transaksi': [50000, 850000, 30000, 620000, 120000,
950000, 25000, 480000, 780000, 40000]
})

# Standarisasi
scaler = StandardScaler()
df_scaled = scaler.fit_transform(df)

# Clustering ke 3 segmen: pelanggan biasa, aktif, VIP
kmeans = KMeans(n_clusters=3, random_state=42)
df['segmen'] = kmeans.fit_predict(df_scaled)

print(df.groupby('segmen').mean())
# Kamu akan melihat 3 kelompok dengan karakteristik berbeda
# Segmen 0: transaksi sedikit, nilai kecil → pelanggan baru/jarang
# Segmen 1: transaksi banyak, nilai besar → pelanggan VIP
# Segmen 2: sedang-sedang → pelanggan reguler
</syntaxhighlight>

----

=== 3.3 Evaluasi Model ===

Akurasi bukan satu-satunya metrik! Ini kesalahan yang sangat umum dilakukan pemula.

'''Metrik untuk Klasifikasi:'''
* '''Accuracy''' — persentase prediksi yang benar. Menyesatkan pada data tidak seimbang.
* '''Precision''' — dari semua yang diprediksi positif, berapa yang benar-benar positif?
* '''Recall''' — dari semua yang sebenarnya positif, berapa yang berhasil terdeteksi?
* '''F1 Score''' — rata-rata harmonis precision dan recall
* '''ROC-AUC''' — seberapa baik model memisahkan kelas positif dan negatif

'''Contoh mengapa akurasi bisa menyesatkan:'''
Misalnya dari 1000 pasien, hanya 10 yang benar-benar sakit kanker. Model yang selalu menebak "tidak sakit" akan mendapat akurasi 99% — tapi gagal total mendeteksi pasien yang sakit!

'''Metrik untuk Regresi:'''
* '''MAE (Mean Absolute Error)''' — rata-rata selisih absolut prediksi vs aktual
* '''RMSE (Root Mean Squared Error)''' — lebih sensitif terhadap error besar
* '''R² Score''' — seberapa besar variansi data yang dijelaskan model (0–1, makin tinggi makin baik)

'''Cross-Validation — cara evaluasi yang lebih jujur:'''
<syntaxhighlight lang="python">
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(n_estimators=100, random_state=42)

# 5-fold cross-validation: data dibagi 5, model dilatih 5 kali
scores = cross_val_score(model, X, y, cv=5, scoring='f1')
print(f"F1 per fold : {scores}")
print(f"F1 rata-rata: {scores.mean():.3f} (+/- {scores.std():.3f})")
# Ini memberikan gambaran performa model yang lebih andal
# daripada hanya satu kali train-test split
</syntaxhighlight>

----

=== 3.4 Overfitting & Regularisasi ===

'''Overfitting''' terjadi ketika model terlalu "menghafal" data latih sehingga gagal pada data baru. Ini adalah masalah paling umum dalam ML.

Tanda-tanda overfitting:
* Akurasi data latih sangat tinggi (misal 99%)
* Akurasi data uji jauh lebih rendah (misal 72%)

Cara mengatasinya:
* '''Regularisasi L1/L2''' — menambahkan penalti pada koefisien yang terlalu besar
* '''Cross-validation''' — memastikan model diuji pada berbagai subset data
* '''Pruning''' — memangkas Decision Tree agar tidak terlalu kompleks
* '''Menambah data latih''' — solusi terbaik jika memungkinkan
* '''Dropout''' — teknik khusus deep learning (dibahas di Fase 4)

'''Underfitting''' adalah kebalikannya — model terlalu sederhana, bahkan data latih pun tidak bisa diprediksi dengan baik.

----

== Fase 4 — Deep Learning ==
'''Estimasi waktu: 8–12 minggu'''

Deep learning adalah subset ML yang menggunakan '''neural network''' berlapis-lapis. Sangat powerful untuk data tidak terstruktur seperti gambar, teks, dan audio — tapi membutuhkan lebih banyak data dan komputasi.

'''Penting diketahui:''' Jangan langsung loncat ke deep learning untuk semua masalah. Untuk data tabular terstruktur, Random Forest atau XGBoost sering kali lebih baik dan jauh lebih mudah.

=== 4.1 Neural Network Dasar ===

Neural network terinspirasi dari cara kerja otak manusia. Terdiri dari:
* '''Input layer''' — menerima data
* '''Hidden layer''' — memproses dan belajar representasi
* '''Output layer''' — menghasilkan prediksi

Konsep kunci yang harus dipahami:
* '''Activation function''' — ReLU, Sigmoid, Softmax (memperkenalkan non-linearitas)
* '''Loss function''' — mengukur seberapa salah prediksi model
* '''Backpropagation''' — algoritma untuk menghitung gradien dan memperbarui bobot
* '''Optimizer''' — Adam, SGD (menentukan bagaimana bobot diperbarui)
* '''Epoch & Batch size''' — berapa kali model melihat seluruh data latih

'''Contoh kasus — klasifikasi tulisan tangan dengan Keras:'''
<syntaxhighlight lang="python">
import tensorflow as tf
from tensorflow import keras

# Dataset MNIST: 70.000 gambar angka 0-9 berukuran 28x28 pixel
(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()

# Normalisasi pixel ke skala 0-1
X_train, X_test = X_train / 255.0, X_test / 255.0

# Bangun model sederhana
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)), # 28x28 → 784 neuron
keras.layers.Dense(128, activation='relu'), # hidden layer
keras.layers.Dropout(0.2), # cegah overfitting
keras.layers.Dense(10, activation='softmax') # output: 10 kelas (0-9)
])

model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

model.fit(X_train, y_train, epochs=5, validation_split=0.1)
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"Akurasi test: {test_acc:.4f}") # biasanya ~98%
</syntaxhighlight>

----

=== 4.2 CNN & RNN ===

Dua arsitektur neural network khusus untuk jenis data tertentu:

'''Convolutional Neural Network (CNN)''' — dirancang khusus untuk data gambar. Menggunakan operasi konvolusi untuk mendeteksi fitur visual seperti tepi, tekstur, dan bentuk secara hierarkis.

Digunakan untuk:
* Klasifikasi gambar (kucing vs anjing)
* Deteksi objek (YOLO, Faster R-CNN)
* Segmentasi gambar (medis, satelit)
* Pengenalan wajah

'''Recurrent Neural Network (RNN) & LSTM''' — dirancang untuk data berurutan. Memiliki "memori" yang memungkinkan ia mempertimbangkan konteks dari langkah sebelumnya.

Digunakan untuk:
* Analisis sentimen teks
* Prediksi harga saham (time series)
* Penerjemahan mesin
* Pengenalan suara

'''Transfer Learning — jangan latih dari nol!'''
Untuk sebagian besar proyek praktis, gunakan model yang sudah dilatih (pre-trained model) dan fine-tune untuk kebutuhan spesifikmu. Ini menghemat waktu, data, dan komputasi secara dramatis.
<syntaxhighlight lang="python">
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras import layers, Model

# Gunakan MobileNetV2 yang sudah dilatih pada ImageNet (jutaan gambar)
base_model = MobileNetV2(input_shape=(224, 224, 3),
include_top=False,
weights='imagenet')
base_model.trainable = False # bekukan bobot, jangan latih ulang

# Tambahkan layer klasifikasi untuk kebutuhan kita
x = base_model.output
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(128, activation='relu')(x)
output = layers.Dense(3, activation='softmax')(x) # misal: 3 kelas buah

model = Model(inputs=base_model.input, outputs=output)
# Model ini sekarang bisa mengklasifikasikan buah dengan data latih yang sedikit
</syntaxhighlight>

----

=== 4.3 Transformer & Large Language Model (LLM) ===

Transformer adalah arsitektur yang merevolusi NLP (Natural Language Processing) dan kini menyebar ke bidang lain seperti computer vision dan biologi. Konsep utamanya adalah mekanisme '''attention''' — model belajar untuk "memperhatikan" bagian input yang paling relevan.

Model-model penting yang perlu diketahui:
* '''BERT''' — bagus untuk memahami teks (klasifikasi, NER, QA)
* '''GPT''' — bagus untuk menghasilkan teks
* '''Vision Transformer (ViT)''' — transformer untuk gambar

'''HuggingFace''' adalah ekosistem utama untuk bekerja dengan transformer. Library-nya memudahkan fine-tuning ribuan model pre-trained.

'''Contoh kasus — analisis sentimen ulasan produk:'''
<syntaxhighlight lang="python">
from transformers import pipeline

# Pipeline siap pakai dari HuggingFace — tidak perlu latih dari nol
classifier = pipeline('sentiment-analysis',
model='nlptown/bert-base-multilingual-uncased-sentiment')

ulasan = [
"Produknya bagus banget, pengiriman cepat, sangat puas!",
"Kecewa, barang datang rusak dan tidak sesuai deskripsi.",
"Lumayan lah, sesuai ekspektasi untuk harganya."
]

for teks in ulasan:
hasil = classifier(teks)[0]
print(f"Teks : {teks[:50]}...")
print(f"Label : {hasil['label']} | Skor: {hasil['score']:.2f}\n")
</syntaxhighlight>

----

== Fase 5 — Produksi & Spesialisasi ==
'''Estimasi waktu: Ongoing (terus berkembang)'''

Membuat model yang akurat baru setengah pekerjaan. Fase ini mengajarkan bagaimana mengubah model menjadi produk yang bisa digunakan orang lain.

=== 5.1 MLOps & Deployment ===

MLOps adalah praktik membawa model ML ke lingkungan produksi secara andal dan terukur.

Konsep dan alat yang perlu dipelajari:
* '''Flask / FastAPI''' — membungkus model sebagai REST API
* '''Docker''' — mengemas aplikasi agar bisa berjalan di mana saja
* '''MLflow''' — melacak eksperimen, versi model, dan parameter
* '''Model monitoring''' — memantau performa model di produksi (apakah akurasi menurun?)

'''Contoh kasus — membuat API prediksi dengan FastAPI:'''
<syntaxhighlight lang="python">
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import numpy as np

app = FastAPI()
model = joblib.load('model_kredit.pkl') # load model yang sudah dilatih

class DataNasabah(BaseModel):
usia: float
pendapatan: float
jumlah_hutang: float
lama_kerja: float

@app.post("/prediksi-kredit")
def prediksi(data: DataNasabah):
fitur = np.array([[data.usia, data.pendapatan,
data.jumlah_hutang, data.lama_kerja]])
prediksi = model.predict(fitur)[0]
probabilitas = model.predict_proba(fitur)[0][1]
return {
"keputusan" : "Disetujui" if prediksi == 0 else "Ditolak",
"risiko_gagal": f"{probabilitas:.1%}"
}

# Jalankan: uvicorn app:app --reload
# Test: POST ke http://localhost:8000/prediksi-kredit
</syntaxhighlight>

----

=== 5.2 Proyek Nyata & Portfolio ===

Tidak ada cara belajar ML yang lebih efektif selain mengerjakan proyek nyata. Proyek di portfolio kamu adalah bukti kemampuan yang jauh lebih kuat daripada sertifikat.

'''Rekomendasi platform:'''
* '''Kaggle''' — kompetisi ML, dataset publik, dan notebook komunitas
* '''UCI ML Repository''' — koleksi dataset klasik untuk belajar
* '''GitHub''' — wajib untuk menyimpan dan memamerkan kode proyekmu
* '''Hugging Face''' — untuk proyek NLP dan model sharing

'''Ide proyek berdasarkan tingkat kesulitan:'''

{| class="wikitable"
|-
! Level !! Proyek !! Dataset
|-
| Pemula || Prediksi harga rumah || Boston Housing, Kaggle
|-
| Pemula || Klasifikasi bunga iris || Iris Dataset (scikit-learn)
|-
| Menengah || Deteksi spam email || SMS Spam Collection
|-
| Menengah || Segmentasi pelanggan || E-commerce dataset
|-
| Menengah || Prediksi churn pelanggan || Telco Customer Churn
|-
| Lanjutan || Deteksi penipuan kartu kredit || Kaggle Credit Card Fraud
|-
| Lanjutan || Analisis sentimen ulasan || Indonesian NLP datasets
|-
| Lanjutan || Klasifikasi gambar produk || Open Images Dataset
|}

----

=== 5.3 Jalur Spesialisasi ===

Setelah menguasai fondasi ML, kamu bisa mendalami salah satu bidang ini:

{| class="wikitable"
|-
! Spesialisasi !! Fokus Utama !! Library/Framework Kunci
|-
| '''Natural Language Processing (NLP)''' || Pemahaman dan generasi teks, chatbot, terjemahan || HuggingFace, spaCy, NLTK
|-
| '''Computer Vision''' || Pengenalan gambar, deteksi objek, analisis video || OpenCV, YOLO, Detectron2
|-
| '''Time Series''' || Prediksi data berurutan, anomali, peramalan || Prophet, statsmodels, ARIMA
|-
| '''Reinforcement Learning''' || Agen yang belajar dari interaksi, game AI, robotika || Gym, Stable Baselines3
|-
| '''MLOps/ML Engineering''' || Infrastruktur, deployment, monitoring skala besar || Kubernetes, Airflow, Kubeflow
|}

----

== Referensi & Sumber Belajar yang Direkomendasikan ==

=== Kursus Online ===
* [https://www.coursera.org/specializations/machine-learning-introduction Machine Learning Specialization — Andrew Ng (Coursera)] — terbaik untuk fondasi teori
* [https://course.fast.ai/ Practical Deep Learning for Coders — fast.ai] — pendekatan top-down, langsung praktek
* [https://www.kaggle.com/learn Kaggle Learn] — gratis, singkat, langsung ke praktik

=== Buku ===
* '''Hands-On Machine Learning''' — Aurélien Géron (O'Reilly) — referensi praktik terlengkap
* '''Deep Learning''' — Goodfellow, Bengio, Courville — referensi teori mendalam
* '''Pattern Recognition and Machine Learning''' — Bishop — untuk yang ingin matematika serius

=== Dokumentasi Resmi ===
* [https://scikit-learn.org/stable/user_guide.html Scikit-learn User Guide]
* [https://www.tensorflow.org/tutorials TensorFlow Tutorials]
* [https://pytorch.org/tutorials/ PyTorch Tutorials]
* [https://huggingface.co/docs HuggingFace Documentation]

----

== Catatan Penutup ==

Belajar ML adalah maraton, bukan sprint. Beberapa hal yang perlu selalu diingat:

# '''Pahami dulu, hafalkan belakangan.''' Lebih baik benar-benar mengerti cara kerja 3 algoritma daripada hafal sintaks 20 algoritma tanpa mengerti konsepnya.
# '''Kode setiap hari.''' Konsistensi 30 menit per hari jauh lebih efektif daripada marathon 8 jam di akhir pekan.
# '''Proyek nyata adalah guru terbaik.''' Teori di kursus tidak akan mempersiapkanmu untuk menghadapi data nyata yang berantakan, tidak lengkap, dan penuh kejutan.
# '''Komunitas itu penting.''' Bergabunglah dengan komunitas ML Indonesia di Telegram, Discord, atau forum lokal lainnya.
# '''Jangan takut salah.''' Model yang pertama hampir pasti jelek — dan itu normal. Iterasi adalah inti dari proses ML.

Selamat belajar dan semoga roadmap ini bermanfaat!

Roadmap Belajar Machine Learning dengan Python - Riwayat revisi