Bulan 9: Machine Learning Dasar

import numpy as np
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import mean_absolute_error, r2_score

np.random.seed(42)
n = 500

# Dataset simulasi kos-kosan Indonesia
kota      = np.random.choice(['Jakarta', 'Bandung', 'Surabaya'], n)
tipe      = np.random.choice(['Putra', 'Putri', 'Campur'], n)
fasilitas = np.random.choice(['AC+WiFi', 'WiFi saja', 'Standar'], n)
luas_m2   = np.random.normal(12, 3, n).clip(6, 25)
jarak_km  = np.random.exponential(2, n).clip(0.1, 10)
lantai    = np.random.randint(1, 5, n)

# Harga dasar berdasarkan kota (dalam ribu rupiah per bulan)
base = {'Jakarta': 1500, 'Bandung': 900, 'Surabaya': 800}
harga = np.array([base[k] for k in kota], dtype=float)
harga += luas_m2 * 50
harga -= jarak_km * 80
harga += (fasilitas == 'AC+WiFi').astype(float) * 400
harga += (fasilitas == 'WiFi saja').astype(float) * 150
harga += np.random.normal(0, 150, n)
harga = harga.clip(300, 5000)

df = pd.DataFrame({
    'kota': kota, 'tipe': tipe, 'fasilitas': fasilitas,
    'luas_m2': luas_m2, 'jarak_km': jarak_km,
    'lantai': lantai, 'harga_ribu': harga
})

X = df.drop('harga_ribu', axis=1)
y = df['harga_ribu']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

num_features = ['luas_m2', 'jarak_km', 'lantai']
cat_features = ['kota', 'tipe', 'fasilitas']

preprocessor = ColumnTransformer([
    ('num', Pipeline([
        ('imp', SimpleImputer(strategy='median')),
        ('scl', StandardScaler())
    ]), num_features),
    ('cat', OneHotEncoder(handle_unknown='ignore'), cat_features)
])

pipeline = Pipeline([
    ('prep', preprocessor),
    ('model', GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, random_state=42))
])

pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)

mae = mean_absolute_error(y_test, y_pred)
r2  = r2_score(y_test, y_pred)
print(f"MAE: Rp {mae:.0f} ribu/bulan")
print(f"R-squared: {r2:.3f}")

# Cek apakah error model merata antar kota (fairness check)
for kota_nama in ['Jakarta', 'Bandung', 'Surabaya']:
    mask = X_test['kota'] == kota_nama
    if mask.any():
        mae_kota = mean_absolute_error(y_test[mask], y_pred[mask])
        print(f"  MAE {kota_nama}: Rp {mae_kota:.0f} ribu")

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, roc_auc_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

np.random.seed(42)
n_normal = 9800
n_fraud  = 200  # hanya 2% fraud

# Simulasi transaksi normal (pola aktivitas siang hari, jumlah wajar)
normal = pd.DataFrame({
    'jumlah_rp':        np.random.lognormal(13, 1.5, n_normal),
    'jam':              np.random.choice(range(8, 22), n_normal),
    'frekuensi_harian': np.random.poisson(2, n_normal),
    'selisih_lokasi_km': np.random.exponential(5, n_normal),
    'label': 0
})

# Simulasi fraud (jumlah besar, tengah malam, frekuensi tinggi, lokasi jauh)
fraud = pd.DataFrame({
    'jumlah_rp':        np.random.lognormal(15, 2, n_fraud),
    'jam':              np.random.choice(range(0, 6), n_fraud),
    'frekuensi_harian': np.random.poisson(15, n_fraud),
    'selisih_lokasi_km': np.random.exponential(200, n_fraud),
    'label': 1
})

df = pd.concat([normal, fraud]).sample(frac=1, random_state=42).reset_index(drop=True)
X  = df.drop('label', axis=1)
y  = df['label']

print(f"Proporsi fraud: {y.mean():.2%}")

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

# Model 1: tanpa penanganan imbalanced
pipe_default = Pipeline([
    ('scl', StandardScaler()),
    ('clf', RandomForestClassifier(n_estimators=100, random_state=42))
])
pipe_default.fit(X_train, y_train)

# Model 2: dengan class_weight='balanced'
pipe_balanced = Pipeline([
    ('scl', StandardScaler()),
    ('clf', RandomForestClassifier(n_estimators=100, class_weight='balanced', random_state=42))
])
pipe_balanced.fit(X_train, y_train)

print("\n--- Model Default ---")
print(classification_report(y_test, pipe_default.predict(X_test),
      target_names=['Normal', 'Fraud']))

print("--- Model Balanced ---")
print(classification_report(y_test, pipe_balanced.predict(X_test),
      target_names=['Normal', 'Fraud']))

# AUC-ROC: metrik paling tepat untuk data imbalanced
auc_d = roc_auc_score(y_test, pipe_default.predict_proba(X_test)[:,1])
auc_b = roc_auc_score(y_test, pipe_balanced.predict_proba(X_test)[:,1])
print(f"AUC-ROC Default : {auc_d:.4f}")
print(f"AUC-ROC Balanced: {auc_b:.4f}")

import numpy as np
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import StratifiedKFold, cross_val_score
import warnings
warnings.filterwarnings('ignore')

np.random.seed(42)
n = 800

df = pd.DataFrame({
    'nilai_rata':         np.random.normal(72, 15, n).clip(30, 100),
    'absensi_persen':     np.random.exponential(8, n).clip(0, 60),
    'jarak_sekolah_km':  np.random.exponential(3, n).clip(0.5, 25),
    'pendapatan_ortu':    np.random.choice(['rendah', 'menengah', 'tinggi'], n,
                                            p=[0.45, 0.40, 0.15]),
    'ekskul_aktif':       np.random.randint(0, 4, n),
    'punya_hp':           np.random.choice([0, 1], n, p=[0.3, 0.7]),
    'kelas':              np.random.choice(['X', 'XI', 'XII'], n)
})

# Probabilitas dropout berdasarkan kombinasi faktor risiko
risiko = (
    df['nilai_rata'].lt(60).astype(int) * 2 +
    df['absensi_persen'].gt(20).astype(int) * 3 +
    df['pendapatan_ortu'].eq('rendah').astype(int) * 2 +
    df['jarak_sekolah_km'].gt(10).astype(int) +
    df['ekskul_aktif'].eq(0).astype(int)
)
prob_dropout = 1 / (1 + np.exp(-(risiko - 4)))
df['dropout'] = (np.random.random(n) < prob_dropout).astype(int)
print(f"Proporsi siswa dropout: {df['dropout'].mean():.2%}")

X = df.drop('dropout', axis=1)
y = df['dropout']

num_cols = ['nilai_rata', 'absensi_persen', 'jarak_sekolah_km', 'ekskul_aktif', 'punya_hp']
cat_cols = ['pendapatan_ortu', 'kelas']

preprocessor = ColumnTransformer([
    ('num', Pipeline([
        ('imp', SimpleImputer(strategy='median')),
        ('scl', StandardScaler())
    ]), num_cols),
    ('cat', Pipeline([
        ('imp', SimpleImputer(strategy='most_frequent')),
        ('enc', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
    ]), cat_cols)
])

models = {
    'Logistic Regression': LogisticRegression(max_iter=1000),
    'Decision Tree':        DecisionTreeClassifier(max_depth=5, random_state=42),
    'Random Forest':        RandomForestClassifier(n_estimators=100, random_state=42)
}

skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
print(f"\n{'Model':<25} {'F1 Mean':>10} {'F1 Std':>10} {'Recall':>10}")
print("-" * 58)
for nama, clf in models.items():
    pipe = Pipeline([('prep', preprocessor), ('clf', clf)])
    f1  = cross_val_score(pipe, X, y, cv=skf, scoring='f1')
    rec = cross_val_score(pipe, X, y, cv=skf, scoring='recall')
    print(f"{nama:<25} {f1.mean():>10.3f} {f1.std():>10.3f} {rec.mean():>10.3f}")

import joblib
import numpy as np
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Langkah 1: Latih pipeline seperti biasa
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
feature_names = X.columns.tolist()

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model',  RandomForestClassifier(n_estimators=100, random_state=42))
])
pipeline.fit(X_train, y_train)

print("Evaluasi pada test set:")
print(classification_report(y_test, pipeline.predict(X_test),
      target_names=['Malignant', 'Benign']))

# Langkah 2: Simpan seluruh pipeline ke satu file
joblib.dump(pipeline, 'model_diagnostik.pkl')
print("Pipeline disimpan ke model_diagnostik.pkl")

# Langkah 3: Hapus dari memori, simulasi sesi baru
del pipeline

# Langkah 4: Load model yang sudah disimpan
pipeline_loaded = joblib.load('model_diagnostik.pkl')
print("Model berhasil di-load. Siap digunakan tanpa training ulang.")

# Langkah 5: Prediksi sampel baru (simulasi pasien baru datang)
sampel_baru = X_test.iloc[[0]]
prediksi    = pipeline_loaded.predict(sampel_baru)[0]
prob        = pipeline_loaded.predict_proba(sampel_baru)[0]

label_map = {0: 'Malignant (ganas)', 1: 'Benign (jinak)'}
print(f"\nHasil prediksi sampel baru:")
print(f"  Kelas          : {label_map[prediksi]}")
print(f"  Prob Malignant : {prob[0]:.2%}")
print(f"  Prob Benign    : {prob[1]:.2%}")
print(f"  Label asli     : {label_map[y_test.iloc[0]]}")