from sklearn.model_selection import TimeSeriesSplit
import pandas as pd

# Data harga saham (harus terurut berdasarkan waktu)
df = df.sort_values('tanggal')  # pastikan terurut!

# ❌ JANGAN pakai ini untuk time-series:
# X_train, X_test = train_test_split(X, test_size=0.2)  # shuffle = leakage!

# ✅ Gunakan TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)

for fold, (train_idx, test_idx) in enumerate(tscv.split(X)):
    X_train, X_test = X[train_idx], X[test_idx]
    y_train, y_test = y[train_idx], y[test_idx]
    
    # Train hanya pakai data HISTORIS
    # Test selalu ada SETELAH training period
    print(f"Fold {fold+1}: Train[{train_idx[0]}:{train_idx[-1]}] → Test[{test_idx[0]}:{test_idx[-1]}]")

import numpy as np
import random
import os

def set_all_seeds(seed=42):
    """Set semua random seed untuk reproducibility penuh."""
    
    # Python built-in random
    random.seed(seed)
    
    # NumPy
    np.random.seed(seed)
    
    # Hash seed untuk Python (mencegah non-determinisme pada dict)
    os.environ['PYTHONHASHSEED'] = str(seed)
    
    # TensorFlow / Keras (jika digunakan)
    try:
        import tensorflow as tf
        tf.random.set_seed(seed)
    except ImportError:
        pass
    
    # PyTorch (jika digunakan)
    try:
        import torch
        torch.manual_seed(seed)
        torch.cuda.manual_seed_all(seed)
        torch.backends.cudnn.deterministic = True
    except ImportError:
        pass
    
    print(f"✅ Semua random seed di-set ke: {seed}")

# Panggil di awal setiap notebook/script
set_all_seeds(42)

# Selalu gunakan random_state di Scikit-learn
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42  # ← WAJIB!
)

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score

# Mulai eksperimen
mlflow.set_experiment("klasifikasi-churn-pelanggan")

with mlflow.start_run(run_name="random-forest-v1"):
    # Parameter yang digunakan
    params = {
        "n_estimators": 100,
        "max_depth": 5,
        "random_state": 42
    }
    mlflow.log_params(params)
    
    # Latih model
    model = RandomForestClassifier(**params)
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    
    # Catat metrik
    mlflow.log_metric("accuracy", accuracy_score(y_test, y_pred))
    mlflow.log_metric("f1_score", f1_score(y_test, y_pred))
    
    # Simpan model sebagai artefak
    mlflow.sklearn.log_model(model, "model")
    
    print("Eksperimen berhasil dicatat di MLflow!")

# Jalankan UI: mlflow ui → buka http://localhost:5000

ml-project/
├── data/
│   ├── raw/              # Data mentah — JANGAN diubah!
│   ├── processed/        # Data setelah preprocessing
│   └── external/         # Data dari sumber eksternal
├── notebooks/
│   ├── 01_eda.ipynb      # Eksplorasi data
│   ├── 02_features.ipynb # Feature engineering
│   └── 03_modeling.ipynb # Training & evaluasi
├── src/
│   ├── data/             # Script preprocessing
│   ├── features/         # Script feature engineering
│   ├── models/           # Script training
│   └── utils/            # Helper functions
├── models/               # Model tersimpan (.pkl, .joblib)
├── reports/              # Grafik & laporan
├── requirements.txt      # Dependensi Python
├── config.yaml           # Konfigurasi hyperparameter
└── README.md             # Dokumentasi proyek

from sklearn.metrics import classification_report, confusion_matrix
from sklearn.metrics import roc_auc_score, average_precision_score

# ❌ JANGAN hanya gunakan akurasi untuk imbalanced data
accuracy = (y_pred == y_test).mean()  # bisa menipu!

# ✅ Gunakan metrik yang tepat
print(classification_report(y_test, y_pred))
# Output: precision, recall, f1-score per kelas

# ROC-AUC: bagus untuk imbalanced
roc_auc = roc_auc_score(y_test, y_prob)

# PR-AUC: lebih baik dari ROC-AUC untuk sangat imbalanced
pr_auc = average_precision_score(y_test, y_prob)

# Tangani imbalance dengan class_weight
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(class_weight='balanced', random_state=42)

# Atau gunakan SMOTE untuk oversampling
from imblearn.over_sampling import SMOTE
X_resampled, y_resampled = SMOTE(random_state=42).fit_resample(X_train, y_train)

from sklearn.model_selection import cross_val_score, StratifiedKFold
import numpy as np

# ❌ Jangan hanya evaluasi sekali
model.fit(X_train, y_train)
score = model.score(X_test, y_test)  # hasil mungkin tidak representatif

# ✅ Gunakan Stratified K-Fold Cross Validation
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

scores = cross_val_score(
    pipeline,      # gunakan pipeline, bukan model saja!
    X, y,
    cv=cv,
    scoring='f1',
    n_jobs=-1      # paralel processing
)

print(f"F1 Scores per fold: {scores.round(3)}")
print(f"Mean F1: {scores.mean():.3f} ± {scores.std():.3f}")
# Output: F1 Scores per fold: [0.84 0.86 0.83 0.87 0.85]
# Output: Mean F1: 0.850 ± 0.014

# Deteksi overfitting: bandingkan train vs test score
train_score = model.score(X_train, y_train)
test_score  = model.score(X_test, y_test)
gap = train_score - test_score

print(f"Train Accuracy: {train_score:.3f}")
print(f"Test  Accuracy: {test_score:.3f}")
print(f"Gap           : {gap:.3f}")

# Diagnosa:
if gap > 0.1:
    print("⚠️  Kemungkinan OVERFITTING — kurangi kompleksitas model")
elif test_score < 0.7:
    print("⚠️  Kemungkinan UNDERFITTING — tingkatkan kompleksitas model")
else:
    print("✅ Model generalisasi dengan baik!")

# Solusi overfitting:
# - Regularization (L1/L2)
# - Kurangi max_depth pada tree
# - Tambah data training
# - Feature selection
# - Dropout (untuk neural network)

from sklearn.dummy import DummyClassifier

# ✅ SELALU buat baseline dulu!
# Baseline 1: Prediksi selalu kelas mayoritas
dummy_majority = DummyClassifier(strategy='most_frequent')
dummy_majority.fit(X_train, y_train)
baseline_score = dummy_majority.score(X_test, y_test)
print(f"Baseline (majority): {baseline_score:.3f}")

# Baseline 2: Model paling sederhana (Logistic Regression)
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(random_state=42)
lr.fit(X_train, y_train)
lr_score = lr.score(X_test, y_test)
print(f"Logistic Regression: {lr_score:.3f}")

# Model kompleks kamu
rf_score = rf_model.score(X_test, y_test)
print(f"Random Forest      : {rf_score:.3f}")

# Jika RF tidak jauh lebih baik dari LR → mungkin tidak perlu kompleksitas ekstra