Setelah beberapa episode bicara konsep, sekarang saatnya turun ke alat. Pertanyaan yang dulu bikin saya bingung: mau mulai belajar AI, pakai library apa? scikit-learn? TensorFlow? PyTorch? Terus Hugging Face itu apa, framework atau toko model? Episode ini catatan saya memetakan empat nama besar itu — kapan dipakai apa, dan kenapa saya akhirnya berhenti bingung.
Peta Besar: Empat Lapis Alat
Cara paling gampang mengingat: bayangkan stack seperti dunia web. scikit-learn itu seperti standard library untuk machine learning klasik — API konsisten fit(), predict(), cocok untuk data tabular dan prototyping cepat. TensorFlow dan PyTorch adalah framework deep learning — level lebih rendah, Anda mendesain arsitektur jaringan saraf sendiri. PyTorch dominan di riset dan banyak paper, TensorFlow kuat di ekosistem produksi (TF Serving, TFLite). Hugging Face bukan pesaing ketiganya; ia lapisan di atasnya: hub model pretrained, library transformers/datasets, dan API yang menyatukan semuanya.
Saya analogikan begini: scikit-learn itu seperti Honda Civic — andal, hemat biaya, cocok untuk harian. PyTorch itu mobil sport yang mesinnya bisa Anda bongkar pasang sendiri. TensorFlow lebih seperti truk logistik — dirancang untuk mengirim model ke mana-mana. Hugging Face? Marketplace yang jual mesin bekas berkualitas tinggi siap pakai. Anda tinggal pilih, pasang, jalan.
Tabel Perbandingan
| Alat | Fokus | Kekuatan | Kapan saya pakai |
|---|---|---|---|
| scikit-learn | ML klasik | API seragam, cepat untuk tabular | Baseline, data tabular, proyek kecil |
| PyTorch | Deep learning | Fleksibel, dominan riset, debugging pythonic | Eksperimen model, ikut tutorial paper |
| TensorFlow/Keras | Deep learning | Ekosistem deployment lengkap | Butuh TFLite/Serving dari awal |
| Hugging Face | Ekosistem model & dataset | Ribuan pretrained model, transformers API | NLP/LLM, fine-tuning, demo cepat |
Perbandingan Komunitas & Ekosistem
Angka di GitHub bisa menjadi panduan kasar seberapa hidup sebuah proyek. Per September 2025: scikit-learn memiliki sekitar 60 ribu GitHub stars, TensorFlow sekitar 186 ribu, PyTorch sekitar 86 ribu, dan repositori transformers milik Hugging Face menembus lebih dari 140 ribu stars. Angka ini bukan tomuter akurasi — tetapi menunjukkan satu hal: PyTorch dan Hugging Face mengalami pertumbuhan paling cepat dalam dua tahun terakhir.
Di StackOverflow, pertanyaan bertags TensorFlow masih paling banyak secara kumulatif, tetapi pertanyaan baru per minggu untuk PyTorch sudah melampaui TensorFlow sejak pertengahan 2023. Hugging Face mulai muncul secara signifikan di StackOverflow sejak tren LLM meledak. Untuk lowongan kerja, LinkedIn di Indonesia menunjukkan pola menarik: perusahaan yang butuh “AI Engineer” umumnya minta Python + PyTorch atau TensorFlow. Sedangkan untuk “NLP Engineer” atau “ML Engineer” di startup, Hugging Face dan transformers hampir selalu masuk di daftar skill yang dicari.
Pelajaran dari angka-angka ini: pilih framework yang komunitasnya aktif, bukan yang stars-nya paling banyak. Komunitas aktif artinya pertanyaan Anda kemungkinan besar sudah dijawab di forum atau diskusi GitHub.
Instalasi
Selalu pakai virtual environment — jangan pernah install global. Perintah dasar:
python -m venv .venv source .venv/bin/activate # scikit-learn pip install scikit-learn # PyTorch (cek perintah persisnya di pytorch.org sesuai OS/CUDA) pip install torch torchvision # TensorFlow pip install tensorflow # Hugging Face pip install transformers datasets accelerate
Setup GPU (NVIDIA CUDA)
Jika Anda punya GPU NVIDIA, langkah ini sering jadi sumber error pertama. Pastikan driver NVIDIA sudah terinstall — cek dengan nvidia-smi di terminal. Lihat kolom “CUDA Version” di outputnya: itu versi CUDA maksimum yang didukung driver Anda.
Setelah tahu versi CUDA yang kompatibel, install PyTorch sesuai. Bukan pip install torch biasa — gunakan command generator di pytorch.org. Contoh untuk CUDA 12.1:
# Contoh untuk CUDA 12.1 (ganti sesuai versi CUDA Anda) pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 # Verifikasi GPU terdeteksi python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"
TensorFlow lebih mudah: pip install tensorflow[and-cuda] otomatis mendeteksi CUDA. Untuk Hugging Face, pastikan PyTorch atau TensorFlow sudah benar dulu — library itu dibangun di atasnya. Jika tanpa GPU, semua framework tetap jalan di CPU; hanya pelatihan model besar jadi sangat lambat.
Kesalahan Umum Pemula dalam Memilih Framework
Dari pengalaman saya dan baca di forum, berikut kesalahan yang paling sering terjadi:
- Langsung pakai TensorFlow tanpa dasar Python yang kuat. TensorFlow punya banyak abstraksi — Keras, tf.function, tf.data — yang membingungkan kalau dasar Python dan numpy belum solid. Saya pernah menghabiskan dua hari debug error sebenarnya karena shape tensor tidak match, bukan karena TensorFlow-nya.
- Menganggap scikit-learn “kurang canggih”. Banyak problem di dunia nyata diselesaikan dengan baik oleh RandomForest atau XGBoost tanpa perlu neural network. Saya pernah membuat model yang akuratnya 94% pakai scikit-learn, padahal rekan saya pakai deep learning dapat 95% — tapi butuh GPU dan waktu training tiga jam lebih lama.
- Copy-paste kode Hugging Face tanpa paham pipeline-nya.
pipeline("text-generation")memang gampang, tapi kalau tidak paham bagaimana tokenizer bekerja atau apa parametermax_length, hasilnya bisa mengejutkan — atau memakan semua VRAM Anda. - Takut “salah pilih”. Tidak ada framework yang salah. Saya sendiri pakai ketiganya dalam proyek yang berbeda — bahkan dalam proyek yang sama. scikit-learn untuk baseline, PyTorch untuk eksperimen arsitektur, Hugging Face untuk fine-tuning model besar.
Rasa Masing-masing dalam Kode
Contoh scikit-learn melatih classifier dalam lima baris:
from sklearn.datasets import load_iris from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score X, y = load_iris(return_X_y=True) X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42) clf = RandomForestClassifier(random_state=42) clf.fit(X_tr, y_tr) print(accuracy_score(y_te, clf.predict(X_te)))
Sekarang bandingkan dengan PyTorch. Di sini Anda mendefinisikan model, loss function, dan optimizer secara eksplisit — lebih verbose, tetapi Anda tahu persis apa yang terjadi di setiap layer:
import torch
import torch.nn as nn
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import numpy as np
X, y = load_iris(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)
X_tr = torch.tensor(X_tr, dtype=torch.float32)
y_tr = torch.tensor(y_tr, dtype=torch.long)
X_te = torch.tensor(X_te, dtype=torch.float32)
model = nn.Sequential(
nn.Linear(4, 16),
nn.ReLU(),
nn.Linear(16, 3)
)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
for epoch in range(100):
output = model(X_tr)
loss = criterion(output, y_tr)
optimizer.zero_grad()
loss.backward()
optimizer.step()
with torch.no_grad():
pred = model(X_te).argmax(dim=1)
acc = (pred.numpy() == y_te).mean()
print(f"Akurasi: {acc:.4f}")Anda lihat perbedaannya? Di scikit-learn, satu baris clf.fit(). Di PyTorch, Anda menulis training loop sendiri — keuntungannya adalah kontrol penuh atas setiap langkah, yang sangat berguna saat model mulai kompleks.
Terakhir, Hugging Face transformers. Ini contoh memuat model bahasa dan menghasilkan teks — tidak perlu training dari awal:
from transformers import pipeline
# Sentiment analysis dengan model yang sudah dilatih
clf = pipeline("sentiment-analysis")
print(clf("Belajar AI ternyata seru juga!"))
# Text generation — memuat model GPT-2
generator = pipeline("text-generation", model="gpt2")
result = generator("Hari ini saya belajar tentang", max_length=50, num_return_sequences=1)
print(result[0]["generated_text"])Dua puluh detik sampai model NLP jalan — itulah daya tarik ekosistem HF. Di PyTorch level yang sama butuh definisi model, loop training, dan optimizer manual; lebih verbose tapi Anda paham tiap lapisan.
Workflow Saya Sehari-hari
Setelah beberapa bulan menggunakan ketiganya, berikut pola yang saya pakai saat mengerjakan proyek AI:
Langkah 1 — Cek jenis data. Jika datanya berbentuk tabel (CSV, database), saya langsung ke scikit-learn. Buat baseline dulu — akurasi berapa tanpa neural network? Ini penting sebagai benchmark. Saya pernah kaget karena model XGBoost ternyata lebih baik dari CNN untuk dataset tertentu. Jangan pernah skip langkah ini.
Langkah 2 — Butuh model pretrained? Jika tugasnya NLP (klasifikasi teks, summarization, translation, sentiment), saya langsung ke Hugging Face. Cari model yang relevan di huggingface.co/models, baca kartu modelnya, cek license, lalu mulai dengan pipeline(). Jika hasilnya kurang, baru saya fine-tune dengan trainer HF — tidak perlu menulis training loop dari nol.
Langkah 3 — Butuh custom architecture? Jika tugasnya computer vision dengan arsitektur khusus, atau research yang mengikuti paper terbaru, saya pakai PyTorch. Fleksibilitas menulis setiap layer dan training loop membuat eksperimen jadi lebih cepat. Jupyter notebook dengan PyTorch adalah senjata rahasia saya untuk iterasi model.
Langkah 4 — Deploy ke produksi? Jika model sudah final dan perlu di-deploy di server atau mobile, saya pertimbangkan TensorFlow Serving atau TFLite. Atau kalau sudah pakai Hugging Face, bisa pakai optimum library mereka untuk export model ke format ONNX atau OpenVINO.
Rekomendasi Learning Path Berdasarkan Goal
Berikut jalur belajar yang saya rekomendasikan berdasarkan apa yang ingin Anda capai:
| Goal Anda | Jalur Belajar | Estimasi Waktu |
|---|---|---|
| Analisis data bisnis | Python dasar → Pandas → scikit-learn → XGBoost | 2-4 minggu |
| Buat model NLP sederhana | Python → scikit-learn → Hugging Face pipeline() | 1-2 minggu |
| Research / ikuti paper | Python → PyTorch dasar → baca paper + implementasi | 4-8 minggu |
| AI Engineer / MLOps | Python → PyTorch + scikit-learn → Hugging Face → Docker + deployment | 3-6 bulan |
| Mobile AI | Python dasar → TensorFlow/Keras → TFLite → Android/iOS integration | 2-4 bulan |
Poin pentingnya: jangan coba pelajari semuanya sekaligus. Mulai dari satu jalur yang sesuai goal Anda, kuasai dulu, lalu tambah framework lain saat dibutuhkan. Saya sendiri mulai dari scikit-learn, lalu PyTorch saat tertarik deep learning, dan baru pakai Hugging Face saat mulai berurusan dengan model bahasa besar.
Saran Jalur Belajar
- Mulai dari scikit-learn untuk memahami konsep ML dasar tanpa terjebak detail GPU.
- Lanjut PyTorch kalau mau serius deep learning — komunitas dan materi belajarnya paling hidup.
- Pelajari Hugging Face bersamaan: transformers, datasets, dan trainer-nya menghemat waktu besar.
- TensorFlow opsional; pelajari kalau target kerja/klien memang ekosistem TF.
Dulu saya mengira harus “memilih kubu”. Kenyataannya mereka koeksis: baseline scikit-learn, eksperimen PyTorch, distribusi model lewat Hugging Face. Pilih alat dari masalah yang mau diselesaikan, bukan dari hype.
Komentar Terbaru