analytics/satisfaction_model.py

"""
Satisfaction Prediction — Decision Tree, Naive Bayes, Evaluation
=================================================================
CLO5: Classification (ID3/C4.5, Naive Bayes), Evaluation metrics

Predict: Khách hàng có hài lòng không? (review_score >= 4)
Features: delivery_days, price, freight_ratio, product weight, payment type...

Usage:
    python analytics/satisfaction_model.py --data-dir ./data/raw
"""

import os, sys, logging, argparse, json
import pandas as pd
import numpy as np
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import (classification_report, accuracy_score, confusion_matrix,
                             roc_auc_score, roc_curve, f1_score)
from sklearn.preprocessing import LabelEncoder
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
logger = logging.getLogger(__name__)


def prepare_ml_dataset(data_dir: str) -> pd.DataFrame:
    """Chuẩn bị dataset cho classification."""
    orders = pd.read_csv(os.path.join(data_dir, 'olist_orders_dataset.csv'),
                         parse_dates=['order_purchase_timestamp', 'order_delivered_customer_date',
                                      'order_estimated_delivery_date'])
    items = pd.read_csv(os.path.join(data_dir, 'olist_order_items_dataset.csv'))
    reviews = pd.read_csv(os.path.join(data_dir, 'olist_order_reviews_dataset.csv'))
    products = pd.read_csv(os.path.join(data_dir, 'olist_products_dataset.csv'))
    payments = pd.read_csv(os.path.join(data_dir, 'olist_order_payments_dataset.csv'))
    customers = pd.read_csv(os.path.join(data_dir, 'olist_customers_dataset.csv'))

    # Filter delivered + reviewed
    orders = orders[orders['order_status'] == 'delivered']
    orders = orders.merge(reviews[['order_id', 'review_score']], on='order_id', how='inner')

    # Delivery features
    mask = orders['order_delivered_customer_date'].notna() & orders['order_purchase_timestamp'].notna()
    orders.loc[mask, 'delivery_days'] = (
        (orders.loc[mask, 'order_delivered_customer_date'] - orders.loc[mask, 'order_purchase_timestamp'])
        .dt.total_seconds() / 86400
    )
    mask2 = orders['order_delivered_customer_date'].notna() & orders['order_estimated_delivery_date'].notna()
    orders.loc[mask2, 'delivery_delay'] = (
        (orders.loc[mask2, 'order_delivered_customer_date'] - orders.loc[mask2, 'order_estimated_delivery_date'])
        .dt.total_seconds() / 86400
    )
    orders['is_late'] = (orders['delivery_delay'] > 0).astype(int)

    # Item aggregates
    item_agg = items.groupby('order_id').agg(
        total_price=('price', 'sum'), total_freight=('freight_value', 'sum'),
        n_items=('order_item_id', 'count'), n_sellers=('seller_id', 'nunique'),
    ).reset_index()

    # Payment aggregates
    pay_agg = payments.groupby('order_id').agg(
        total_payment=('payment_value', 'sum'),
        max_installments=('payment_installments', 'max'),
        primary_payment=('payment_type', lambda x: x.mode()[0] if len(x) > 0 else 'unknown'),
    ).reset_index()

    # Product features (avg per order)
    items_products = items.merge(products[['product_id', 'product_weight_g', 'product_photos_qty',
                                           'product_description_lenght', 'product_name_lenght']],
                                  on='product_id', how='left')
    prod_agg = items_products.groupby('order_id').agg(
        avg_weight=('product_weight_g', 'mean'),
        avg_photos=('product_photos_qty', 'mean'),
        avg_desc_len=('product_description_lenght', 'mean'),
    ).reset_index()

    # Time features
    ts = orders['order_purchase_timestamp']
    orders['purchase_hour'] = ts.dt.hour
    orders['purchase_dayofweek'] = ts.dt.dayofweek
    orders['is_weekend'] = (ts.dt.dayofweek >= 5).astype(int)

    # Customer state
    orders = orders.merge(customers[['customer_id', 'customer_state']], on='customer_id', how='left')

    # Merge all
    df = orders.merge(item_agg, on='order_id', how='left')
    df = df.merge(pay_agg, on='order_id', how='left')
    df = df.merge(prod_agg, on='order_id', how='left')

    # Derived
    df['freight_ratio'] = (df['total_freight'] / df['total_price'].replace(0, np.nan)).fillna(0)

    # Target
    df['satisfied'] = (df['review_score'] >= 4).astype(int)

    # Feature columns
    feature_cols = ['delivery_days', 'delivery_delay', 'is_late', 'total_price', 'total_freight',
                    'freight_ratio', 'n_items', 'n_sellers', 'max_installments',
                    'avg_weight', 'avg_photos', 'avg_desc_len',
                    'purchase_hour', 'purchase_dayofweek', 'is_weekend']

    df = df.dropna(subset=['delivery_days', 'review_score'])

    # Fill remaining NaN with median
    for c in feature_cols:
        if c in df.columns:
            df[c] = df[c].fillna(df[c].median())

    logger.info(f"[DATA] ML dataset: {len(df)} samples, {df['satisfied'].mean()*100:.1f}% satisfied")
    return df, feature_cols


def train_and_evaluate(df: pd.DataFrame, feature_cols: list, output_dir: str):
    """Train Decision Tree, Naive Bayes, Random Forest and compare."""
    X = df[feature_cols]
    y = df['satisfied']

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
    logger.info(f"Train: {len(X_train)}, Test: {len(X_test)}")

    models = {
        'Decision Tree (Entropy/ID3)': DecisionTreeClassifier(
            criterion='entropy', max_depth=6, min_samples_leaf=50, random_state=42),
        'Decision Tree (Gini/CART)': DecisionTreeClassifier(
            criterion='gini', max_depth=6, min_samples_leaf=50, random_state=42),
        'Gaussian Naive Bayes': GaussianNB(),
        'Random Forest': RandomForestClassifier(
            n_estimators=100, max_depth=8, min_samples_leaf=30, random_state=42, n_jobs=-1),
    }

    results = {}
    fig, axes = plt.subplots(2, 2, figsize=(14, 10))
    ax_flat = axes.flatten()

    for idx, (name, model) in enumerate(models.items()):
        logger.info(f"\n[MODEL] Training {name}...")
        model.fit(X_train, y_train)
        y_pred = model.predict(X_test)
        y_proba = model.predict_proba(X_test)[:, 1] if hasattr(model, 'predict_proba') else None

        acc = accuracy_score(y_test, y_pred)
        f1 = f1_score(y_test, y_pred)
        auc = roc_auc_score(y_test, y_proba) if y_proba is not None else 0

        # Cross-validation
        cv_scores = cross_val_score(model, X, y, cv=5, scoring='f1')

        results[name] = {
            'accuracy': round(acc, 4), 'f1_score': round(f1, 4), 'auc_roc': round(auc, 4),
            'cv_f1_mean': round(cv_scores.mean(), 4), 'cv_f1_std': round(cv_scores.std(), 4),
        }

        print(f"\n  {'='*60}")
        print(f"  {name}")
        print(f"  {'='*60}")
        print(f"  Accuracy: {acc:.4f} | F1: {f1:.4f} | AUC-ROC: {auc:.4f}")
        print(f"  CV F1: {cv_scores.mean():.4f} ± {cv_scores.std():.4f}")
        print(classification_report(y_test, y_pred, target_names=['Not Satisfied', 'Satisfied']))

        # Feature importance (for tree models)
        if hasattr(model, 'feature_importances_'):
            importance = pd.Series(model.feature_importances_, index=feature_cols).sort_values(ascending=False)
            print(f"  Top 5 Features:")
            for feat, imp in importance.head(5).items():
                print(f"    {feat}: {imp:.4f}")

        # ROC Curve
        if y_proba is not None:
            fpr, tpr, _ = roc_curve(y_test, y_proba)
            ax_flat[idx].plot(fpr, tpr, label=f'{name}\nAUC={auc:.3f}', linewidth=2)
            ax_flat[idx].plot([0, 1], [0, 1], 'k--', alpha=0.3)
            ax_flat[idx].set_xlabel('FPR')
            ax_flat[idx].set_ylabel('TPR')
            ax_flat[idx].set_title(f'{name}')
            ax_flat[idx].legend(fontsize=9)

    plt.suptitle('Model Comparison — ROC Curves', fontsize=14, fontweight='bold')
    plt.tight_layout()
    path = os.path.join(output_dir, 'model_comparison.png')
    plt.savefig(path, dpi=150, bbox_inches='tight')
    plt.close()
    logger.info(f"[VIZ] Saved: {path}")

    # Decision Tree Rules
    dt_model = models['Decision Tree (Entropy/ID3)']
    print(f"\n  DECISION TREE RULES (depth ≤ 3):")
    tree_text = export_text(dt_model, feature_names=feature_cols, max_depth=3)
    for line in tree_text.split('\n')[:25]:
        print(f"    {line}")

    # Feature Importance plot
    fig, ax = plt.subplots(figsize=(10, 6))
    rf_model = models['Random Forest']
    importance = pd.Series(rf_model.feature_importances_, index=feature_cols).sort_values(ascending=True)
    importance.plot(kind='barh', ax=ax, color='#3498db', alpha=0.8)
    ax.set_title('Feature Importance (Random Forest)')
    ax.set_xlabel('Importance')
    path2 = os.path.join(output_dir, 'feature_importance.png')
    plt.savefig(path2, dpi=150, bbox_inches='tight')
    plt.close()
    logger.info(f"[VIZ] Saved: {path2}")

    # Save results
    with open(os.path.join(output_dir, 'model_results.json'), 'w') as f:
        json.dump(results, f, indent=2)

    # Summary
    print(f"\n{'='*70}")
    print(f"  MODEL COMPARISON SUMMARY")
    print(f"{'='*70}")
    print(f"  {'Model':<35} {'Accuracy':>10} {'F1':>8} {'AUC':>8} {'CV F1':>10}")
    print(f"  {'-'*75}")
    for name, r in results.items():
        print(f"  {name:<35} {r['accuracy']:>10.4f} {r['f1_score']:>8.4f} "
              f"{r['auc_roc']:>8.4f} {r['cv_f1_mean']:>7.4f}±{r['cv_f1_std']:.3f}")

    best = max(results.items(), key=lambda x: x[1]['f1_score'])
    print(f"\n  Best model: {best[0]} (F1={best[1]['f1_score']:.4f})")
    print(f"{'='*70}")

    return results


def main():
    parser = argparse.ArgumentParser(description='Satisfaction Prediction Models')
    parser.add_argument('--data-dir', type=str, default='./data/raw')
    parser.add_argument('--output-dir', type=str, default='./data/analytics')
    args = parser.parse_args()
    os.makedirs(args.output_dir, exist_ok=True)

    df, feature_cols = prepare_ml_dataset(args.data_dir)
    results = train_and_evaluate(df, feature_cols, args.output_dir)


if __name__ == '__main__':
    main()