Belajar Machine Learning - Scale: Big Data & AutoML

#Pendahuluan

Di episode-episode sebelumnya kita bekerja dengan data yang muat di RAM — ratusan ribu baris. Episode ini menghadapi pertanyaan skala: bagaimana jika datanya 100 juta baris atau 10 TB?

Masalahnya bukan hanya "lambat". DataFrame Pandas memuat seluruh data ke RAM — data 10 TB akan langsung mematikan server 16GB. Di sinilah kita butuh teknologi baru: pemrosesan out-of-core dan terdistribusi. Kita juga akan membahas AutoML — otomatisasi pencarian model terbaik — dan kapan ia layak dipakai.

#Polars: Pandas yang Jauh Lebih Cepat

Polars adalah DataFrame modern yang ditulis dalam Rust. Dua keunggulan utamanya:

• Lazy evaluation: kalian menyusun query, lalu dieksekusi sekaligus dengan optimalisasi — alih-alih mengeksekusi langkah demi langkah seperti Pandas.
• Multi-core by default: memanfaatkan semua core CPU secara otomatis.

import polars as pl
 
df = pl.scan_csv("data/transaksi_2026.csv")  # lazy, belum dibaca
 
result = (
    df.filter(pl.col("harga") > 100000)
      .group_by("kota")
      .agg(pl.col("harga").mean().alias("rata_harga"))
      .sort("rata_harga", descending=True)
      .collect()  # dieksekusi sekarang
)
print(result)

Untuk dataset besar yang masih muat di RAM, Polars bisa 5-10x lebih cepat dari Pandas — dan migration-nya relatif mudah karena API-nya mirip. Pilihan bijak sebelum pindah ke sistem terdistribusi.

#Dask: Pandas yang Bisa Dijadwalkan

Dask meniru API Pandas, tetapi memecah data menjadi bagian-bagian (chunks) yang diproses lambat-sibuk (lazy) dan bisa dijalankan paralel — bahkan lintas mesin.

import dask.dataframe as dd
 
df = dd.read_csv("data/data_2026/*.csv")  # baca banyak file sekaligus
 
# Sama seperti Pandas, tapi lazy
df["pendapatan_per_umur"] = df["pendapatan"] / df["umur"]
summary = df.groupby("kota")["pendapatan"].mean().compute()
 
print(summary)

Perhatikan .compute() di akhir — itulah trigger eksekusi. Keuntungan Dask: kalian hampir tidak mengubah kode Pandas; ia menangani data yang tidak muat di satu mesin. Kekurangan: jika skala sudah cluster multi-mesin, Spark lebih matang.

#Spark MLlib: Skala Cluster

Apache Spark adalah standar industri untuk pemrosesan data terdistribusi. MLlib adalah modul ML-nya — alat untuk data yang tidak mungkin diproses di satu mesin.

from pyspark.sql import SparkSession
from pyspark.ml.feature import VectorAssembler, StandardScaler
from pyspark.ml.classification import RandomForestClassifier
 
spark = SparkSession.builder.appName("ml-scaled").getOrCreate()
df = spark.read.parquet("data/huge/")
 
assembler = VectorAssembler(
    inputCols=["umur", "pendapatan"], outputCol="features"
)
df_feat = assembler.transform(df)
 
model = RandomForestClassifier(featuresCol="features", labelCol="target")
fitted = model.fit(df_feat)

#Strategi Training Skala Besar

Ketika data melampaui kapasitas satu mesin, beberapa strategi training:

• Sampling: sering kali data 100 juta baris mengandung redundancy — latih di sampel 10 juta dulu untuk eksplorasi, baru full data untuk final.
• Incremental / online learning: SGDRegressor(partial_fit) atau library catboost/xgboost dengan update memproses data dalam batch.
• Distributed training: XGBoost dan LightGBM mendukung training terdistribusi / GPU untuk mempercepat satu mesin besar.
• Feature engineering di distributed engine: lakukan preprocessing (Spark/Dask) lalu export ke format cepat (Parquet) untuk training di mesin yang kuat.

from sklearn.linear_model import SGDRegressor
 
model = SGDRegressor()
for chunk in read_chunks("data/huge.csv", chunksize=100_000):
    model.partial_fit(chunk[X_cols], chunk[y_col])

Incremental learning memungkinkan model "belajar terus" tanpa memuat seluruh data — sekaligus fondasi untuk update berkala di produksi.

#AutoML: Biarkan Mesin Mencari

AutoML mengotomatisasi pencarian model + hyperparameter: ia mencoba berbagai model, tuning, dan kadang feature engineering, lalu mengembalikan yang terbaik. Opsi utama 2026:

from autosklearn.classification import AutoSklearnClassifier
 
automl = AutoSklearnClassifier(
    time_left_for_this_task=600,
    per_run_time_limit=60,
    seed=42,
)
automl.fit(X_train, y_train, dataset_name="churn")
print(automl.leaderboard().head(5))
print(f"Test acc: {automl.score(X_test, y_test):.4f}")

Dalam 10 menit, AutoML mencoba puluhan konfigurasi dan memberi leaderboard — jauh lebih cepat daripada tuning manual untuk masalah standar.

#AutoML vs Manual: Kapan Pakai yang Mana

Pandangan yang sehat: AutoML bukan pengganti engineer, tapi asisten. Ia menghasilkan baseline kompetitif dalam waktu singkat, membebaskan kalian fokus pada data, fitur, dan domain — tempat nilai terbesar sebenarnya berada.

#Praktik: Skala dengan Polars + LightGBM

Contoh alur skala menengah yang realistis — preprocessing dengan Polars, training dengan LightGBM:

import polars as pl
import lightgbm as lgb
 
df = pl.read_csv("data/large_2026.csv")
 
df = df.with_columns(
    (pl.col("harga") / pl.col("qty")).alias("harga_per_unit")
)
df = df.drop_nulls()
 
X = df.drop("target").to_pandas()
y = df["target"].to_pandas()
 
model = lgb.LGBMClassifier(n_estimators=300, random_state=42)
model.fit(X, y)

#Common Pitfalls

• Langsung Spark untuk data yang muat di RAM — overhead cluster tidak sepadan.
• pd.read_csv pada file 10GB — RAM habis; pakai Polars/Dask dengan lazy.
• AutoML tanpa deadline — pencarian tak berhenti, biaya komputasi membengkak.
• Memakai AutoML hasil tanpa memvalidasi — tetap perlu CV dan test (episode 10).
• Training full data setiap eksperimen — gunakan sampel untuk iterasi cepat.

#Penutup

Pada episode 22 ini, kalian telah memahami scaling dan AutoML.

Inti yang harus dibawa pulang:

• Polars untuk cepat di satu mesin; Dask untuk tidak muat RAM; Spark MLlib untuk cluster.
• Strategi besar: sampling, incremental learning, distributed training.
• AutoML (auto-sklearn, H2O, TPOT) menghasilkan baseline kompetitif dengan cepat.
• AutoML adalah asisten, bukan pengganti — gunakan sesuai konteks.

Di episode 23 selanjutnya kita melihat ekosistem & tren modern 2026 — scikit-learn 1.8.x, PyTorch 2.11, Polars, dan integrasi ML klasik dengan LLM/RAG melalui hybrid pipeline untuk aplikasi end-to-end. Sampai jumpa di episode 23!