Prediksi Defect dengan Machine Learning

# ================================================================
# S11409 - Sesi 9: Software Defect Prediction (SDP) Pipeline
# Dataset: NASA KC1 (simulasi dengan fitur realistis)
# Dosen: Riadi Marta Dinata, S.Ti., M.Kom. | ISTN Jakarta
# ================================================================
# pip install scikit-learn imbalanced-learn xgboost pandas numpy
#             matplotlib seaborn shap

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import warnings; warnings.filterwarnings('ignore')

from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (classification_report, confusion_matrix,
                               roc_auc_score, RocCurveDisplay)
from imblearn.over_sampling import SMOTE
from imblearn.pipeline import Pipeline as ImbPipeline
import xgboost as xgb

# ── STEP 1: BUAT DATASET SIMULASI NASA KC1-STYLE ──
np.random.seed(42)
n_samples = 1000

# Fitur kode (terinspirasi NASA KC1)
df = pd.DataFrame({
    # Halstead Metrics
    'halstead_volume':   np.random.lognormal(5, 1.5, n_samples),
    'halstead_effort':   np.random.lognormal(8, 2.0, n_samples),
    'halstead_difficulty': np.random.lognormal(2, 1.0, n_samples),

    # McCabe / Cyclomatic Complexity
    'cyclomatic_complexity': np.random.lognormal(1.5, 0.8, n_samples).astype(int) + 1,
    'essential_complexity': np.random.lognormal(1.2, 0.7, n_samples).astype(int) + 1,

    # Size Metrics
    'loc':               np.random.lognormal(4, 1.2, n_samples).astype(int),
    'num_operands':      np.random.lognormal(4, 1.0, n_samples).astype(int),
    'num_operators':     np.random.lognormal(3.5, 1.0, n_samples).astype(int),

    # Process Metrics
    'num_commits':       np.random.poisson(8, n_samples),
    'num_authors':       np.random.randint(1, 8, n_samples),
    'code_age_months':   np.random.randint(1, 36, n_samples),
    'prev_bugs':         np.random.poisson(1.5, n_samples),
})

# Label: buggy (1) jika kombinasi fitur berisiko tinggi
# (simulasi hubungan yang realistis)
risk_score = (
    0.3 * (df['cyclomatic_complexity'] > 10).astype(float) +
    0.25 * (df['num_authors'] > 4).astype(float) +
    0.2 * (df['prev_bugs'] > 0).astype(float) +
    0.15 * (df['loc'] > 200).astype(float) +
    0.1 * (df['num_commits'] > 12).astype(float) +
    np.random.normal(0, 0.15, n_samples)   # noise
)
df['buggy'] = (risk_score > 0.5).astype(int)

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

print("="*60)
print("    SOFTWARE DEFECT PREDICTION PIPELINE")
print("    NASA KC1 Style Dataset | S11409 ISTN")
print("="*60)
print(f"\nDataset: {len(df)} modul kode")
print(f"Clean  : {(y==0).sum()} ({(y==0).mean():.1%})")
print(f"Buggy  : {(y==1).sum()} ({(y==1).mean():.1%})")
print(f"Fitur  : {X.shape[1]} fitur")

# ── STEP 2: SPLIT DATA ──
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=42, stratify=y)

print(f"\nTraining: {len(X_train)} | Test: {len(X_test)}")

# ── STEP 3: DEFINISI MODELS ──
models = {
    'Logistic Regression': ImbPipeline([
        ('smote', SMOTE(random_state=42)),
        ('scaler', StandardScaler()),
        ('clf', LogisticRegression(max_iter=1000, random_state=42))
    ]),
    'Random Forest': ImbPipeline([
        ('smote', SMOTE(random_state=42)),
        ('clf', RandomForestClassifier(
            n_estimators=200, max_depth=10,
            class_weight='balanced', random_state=42))
    ]),
    'XGBoost': ImbPipeline([
        ('smote', SMOTE(random_state=42)),
        ('clf', xgb.XGBClassifier(
            n_estimators=200, learning_rate=0.05, max_depth=5,
            scale_pos_weight=3, use_label_encoder=False,
            eval_metric='logloss', random_state=42))
    ]),
}

# ── STEP 4: TRAIN & EVALUATE ──
results = {}
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

print("\n{'Model':<22} {'AUC-ROC':>10} {'F1':>8} {'Recall':>8} {'Precision':>12}")
print("-"*65)

for name, pipeline in models.items():
    pipeline.fit(X_train, y_train)
    y_pred = pipeline.predict(X_test)
    y_prob = pipeline.predict_proba(X_test)[:, 1]

    from sklearn.metrics import f1_score, recall_score, precision_score
    auc  = roc_auc_score(y_test, y_prob)
    f1   = f1_score(y_test, y_pred)
    rec  = recall_score(y_test, y_pred)
    prec = precision_score(y_test, y_pred)

    results[name] = {'auc': auc, 'f1': f1, 'recall': rec,
                     'precision': prec, 'model': pipeline, 'y_pred': y_pred}
    print(f"{name:<22} {auc:>10.3f} {f1:>8.3f} {rec:>8.3f} {prec:>12.3f}")

# ── STEP 5: FEATURE IMPORTANCE (Random Forest) ──
rf_model = results['Random Forest']['model'].named_steps['clf']
feat_imp = pd.Series(rf_model.feature_importances_, index=X.columns)
feat_imp = feat_imp.sort_values(ascending=False).head(8)

print("\n--- Top 8 Feature Importance (Random Forest) ---")
for feat, imp in feat_imp.items():
    bar = '█' * int(imp * 100)
    print(f"  {feat:<25} {bar} {imp:.3f}")

# ── STEP 6: VISUALISASI ──
fig, axes = plt.subplots(1, 3, figsize=(16, 5))
fig.patch.set_facecolor('#0A0608')

# Plot 1: Confusion Matrix terbaik (XGBoost)
ax1 = axes[0]
ax1.set_facecolor('#160C0E')
cm = confusion_matrix(y_test, results['XGBoost']['y_pred'])
sns.heatmap(cm, annot=True, fmt='d', ax=ax1,
            cmap='RdYlGn', linewidths=0.5,
            xticklabels=['Clean','Buggy'], yticklabels=['Clean','Buggy'])
ax1.set_title('Confusion Matrix — XGBoost', color='white', pad=10)
ax1.tick_params(colors='#9B7A80')

# Plot 2: Feature Importance
ax2 = axes[1]
ax2.set_facecolor('#160C0E')
feat_imp.plot(kind='barh', ax=ax2,
              color=['#C8102E','#E8374F','#F97316','#FCD34D',
                     '#22C55E','#38BDF8','#A78BFA','#9B7A80'])
ax2.set_title('Feature Importance (Random Forest)', color='white', pad=10)
ax2.tick_params(colors='#9B7A80')
ax2.invert_yaxis()

# Plot 3: ROC Curve perbandingan
ax3 = axes[2]
ax3.set_facecolor('#160C0E')
colors_roc = {'Logistic Regression': '#38BDF8',
               'Random Forest': '#F97316', 'XGBoost': '#C8102E'}
for name, res in results.items():
    y_prob = res['model'].predict_proba(X_test)[:, 1]
    RocCurveDisplay.from_predictions(
        y_test, y_prob, name=f"{name} (AUC={res['auc']:.3f})",
        ax=ax3, color=colors_roc[name])
ax3.plot([0,1],[0,1], '--', color='#4B5563', label='Random')
ax3.set_title('ROC Curve — Model Comparison', color='white', pad=10)
ax3.tick_params(colors='#9B7A80')
ax3.legend(fontsize=9)
ax3.grid(alpha=0.15)

plt.tight_layout()
plt.savefig('sdp_results.png', dpi=150, facecolor='#0A0608', bbox_inches='tight')
print("\n✅ Hasil tersimpan: sdp_results.png")

# ── STEP 7: PREDIKSI MODUL BARU ──
print("\n--- Prediksi Risiko Modul Kode Baru ---")
modul_baru = pd.DataFrame([
    {'halstead_volume':1200, 'halstead_effort':50000,  'halstead_difficulty':25,
     'cyclomatic_complexity':18, 'essential_complexity':12,
     'loc':320, 'num_operands':180, 'num_operators':120,
     'num_commits':15, 'num_authors':6, 'code_age_months':18, 'prev_bugs':3},
    {'halstead_volume':80,  'halstead_effort':1200,   'halstead_difficulty':3,
     'cyclomatic_complexity':3,  'essential_complexity':2,
     'loc':35,  'num_operands':20,  'num_operators':15,
     'num_commits':3,  'num_authors':1, 'code_age_months':2,  'prev_bugs':0},
])
modul_names = ["PaymentProcessor.py", "StringUtils.py"]
best_model = results['XGBoost']['model']
proba_baru = best_model.predict_proba(modul_baru)[:, 1]

for nama, prob in zip(modul_names, proba_baru):
    risk = "🔴 HIGH RISK" if prob > 0.6 else ("🟡 MEDIUM" if prob > 0.35 else "🟢 LOW RISK")
    print(f"  {nama:<30} Risk: {prob:.1%}  {risk}")