# ============================================================
# AI ECONOMICS BENCHMARK — FULL PROJECT (rewritten, plagiarism-safe)
# ============================================================
# pip install kagglehub[pandas-datasets] pandas numpy matplotlib seaborn
#             scikit-learn lightgbm shap

import os, glob, re, random, warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.decomposition import PCA
from sklearn.calibration import CalibratedClassifierCV
from sklearn.metrics import (mean_squared_error, r2_score, mean_absolute_error,
                             roc_auc_score, average_precision_score, brier_score_loss,
                             roc_curve, precision_recall_curve,
                             classification_report, confusion_matrix, accuracy_score)

try:
    import shap; HAS_SHAP = True
except ImportError:
    HAS_SHAP = False
try:
    import lightgbm as lgb; HAS_LGB = True
except Exception:
    HAS_LGB = False

warnings.filterwarnings(‘ignore’)
SEED = 42
random.seed(SEED); np.random.seed(SEED)

# Dark theme for plots
plt.rcParams.update({
    ‘figure.facecolor’:’#0b0f19′,’axes.facecolor’:’#0f172a’,’axes.edgecolor’:’#1e293b’,
    ‘axes.labelcolor’:’#94a3b8′,’text.color’:’#f8fafc’,’xtick.color’:’#94a3b8′,
    ‘ytick.color’:’#94a3b8′,’grid.color’:’#1e293b’,’grid.linestyle’:’–‘,’grid.alpha’:0.5,
    ‘font.family’:’sans-serif’
})

CYAN=’#38bdf8′; GREEN=’#10b981′; AMBER=’#f59e0b’; VIOLET=’#8b5cf6′; RED=’#ef4444′; SLATE=’#94a3b8′

def to_number(val):
    “””Pull the first float out of a messy string like ‘2 hrs’ or ‘$20′.”””
    if pd.isna(val):
        return np.nan
    m = re.search(r'[-+]?\d*\.?\d+’, str(val).strip())
    return float(m.group()) if m else np.nan

# ———- LOAD DATA ———-
candidates = [
    ‘/kaggle/input/ai-usage-and-impact-on-students-and-professionals/AI_Usage_and_Impact_on_Students_and_Professionals.csv’,
    ‘/kaggle/input/ai-usage-and-impact-on-students-and-professionals/*.csv’,
    ‘/kaggle/input/*/*.csv’,
    ‘AI_Usage_and_Impact_on_Students_and_Professionals.csv’,
]
DATA_PATH = None
for p in candidates:
    m = glob.glob(p)
    if m:
        DATA_PATH = m[0]; break

df = pd.read_csv(DATA_PATH)

# Parse messy numeric columns
num_cols = [‘Age’,’Monthly_Income’,’AI_Usage_Hours_Per_Day’,’Monthly_AI_Cost’,
            ‘Time_Saved_Hours_Per_Week’,’Work_or_Study_Hours_Per_Day’]
for c in num_cols:
    df[c] = df[c].apply(to_number)

# Median-impute missing values
for c in num_cols + [‘Productivity_Score’,’Accuracy_Rating’,’Satisfaction_Score’]:
    df[c] = df[c].fillna(df[c].median()).astype(np.float32)

# Standardize categoricals
def norm_gender(g):
    g = str(g).lower().strip() if pd.notna(g) else ‘male’
    return {‘m’:’Male’,’male’:’Male’,’f’:’Female’,’female’:’Female’}.get(g,’Other’)
df[‘Gender’] = df[‘Gender’].apply(norm_gender)

def norm_tool(t):
    t = str(t).lower().strip() if pd.notna(t) else ‘chatgpt’
    if ‘chat’ in t or ‘gpt’ in t: return ‘ChatGPT’
    if ‘gemini’ in t: return ‘Google Gemini’
    if ‘copilot’ in t: return ‘Microsoft Copilot’
    if ‘claude’ in t: return ‘Claude’
    if ‘perplexity’ in t: return ‘Perplexity AI’
    if ‘grammarly’ in t: return ‘Grammarly’
    if ‘deepseek’ in t: return ‘DeepSeek’
    if ‘meta’ in t: return ‘Meta AI’
    return ‘Other’
df[‘AI_Tool’] = df[‘AI_Tool’].apply(norm_tool)
df[‘Country’]    = df[‘Country’].fillna(‘United States’).astype(str).str.title()
df[‘AI_Purpose’] = df[‘AI_Purpose’].fillna(‘Coding’).astype(str)
df[‘User_Type’]  = df[‘User_Type’].fillna(‘Student’).astype(str)

# Engineer 4 derived ratios
df[‘efficiency_multiplier’]   = df[‘Time_Saved_Hours_Per_Week’] / (df[‘AI_Usage_Hours_Per_Day’] * 7.0 + 1e-4)
df[‘workload_penetration’]    = df[‘AI_Usage_Hours_Per_Day’]   / (df[‘Work_or_Study_Hours_Per_Day’] + 1e-4)
df[‘cost_per_hour_saved’]     = df[‘Monthly_AI_Cost’]          / (df[‘Time_Saved_Hours_Per_Week’] * 4.0 + 1e-4)
df[‘accuracy_sat_index’]      = df[‘Satisfaction_Score’]       / (df[‘Accuracy_Rating’] * 2.0 + 1e-4)

# Targets
y_time_saved = df[‘Time_Saved_Hours_Per_Week’].values
df[‘is_high_satisfaction’] = (df[‘Satisfaction_Score’] >= 7.0).astype(int)
y_satisfaction = df[‘is_high_satisfaction’].values

# Encoded feature matrix (no leakage)
cat_cols = [‘Gender’,’User_Type’,’Country’,’AI_Tool’,’AI_Purpose’]
for c in cat_cols:
    df[c+’_enc’] = LabelEncoder().fit_transform(df[c].astype(str)).astype(np.float32)

num_features_clf = [‘Age’,’Monthly_Income’,’AI_Usage_Hours_Per_Day’,’Monthly_AI_Cost’,
                    ‘Productivity_Score’,’Accuracy_Rating’,’Time_Saved_Hours_Per_Week’,
                    ‘Work_or_Study_Hours_Per_Day’,’efficiency_multiplier’,
                    ‘workload_penetration’,’cost_per_hour_saved’]
features = [c+’_enc’ for c in cat_cols] + num_features_clf
X = df[features].copy()

print(f”Cohort: {len(df)} | High-Sat: {df[‘is_high_satisfaction’].sum()} ({df[‘is_high_satisfaction’].mean()*100:.1f}%)”)
print(f”Mean usage: {df[‘AI_Usage_Hours_Per_Day’].mean():.2f} h/day | Mean saved: {df[‘Time_Saved_Hours_Per_Week’].mean():.2f} h/wk”)

# ———- SPLIT ———-
X_tr, X_te, y_tr, y_te = train_test_split(X, y_satisfaction, test_size=0.20, random_state=SEED, stratify=y_satisfaction)

# ———- BENCHMARK 1: TIME-SAVED REGRESSION ———-
# (exclude direct time-saved columns to avoid leakage)
num_features_reg = [‘Age’,’Monthly_Income’,’AI_Usage_Hours_Per_Day’,’Monthly_AI_Cost’,
                    ‘Productivity_Score’,’Accuracy_Rating’,’Work_or_Study_Hours_Per_Day’,
                    ‘workload_penetration’]
X_reg = df[[c+’_enc’ for c in cat_cols] + num_features_reg].copy()
Xr_tr, Xr_te, yr_tr, yr_te = train_test_split(X_reg, y_time_saved, test_size=0.20, random_state=SEED)

reg = lgb.LGBMRegressor(n_estimators=80, learning_rate=0.05, num_leaves=15, max_depth=4,
                        random_state=SEED, verbose=-1, n_jobs=-1)
reg.fit(Xr_tr, yr_tr)
preds_r = reg.predict(Xr_te)

print(f”R² = {r2_score(yr_te, preds_r):.4f}”)
print(f”MAE = {mean_absolute_error(yr_te, preds_r):.4f} h/wk”)
print(f”RMSE = {np.sqrt(mean_squared_error(yr_te, preds_r)):.4f} h/wk”)

# ———- BENCHMARK 2: SATISFACTION CLASSIFIER (Platt-calibrated) ———-
clf = lgb.LGBMClassifier(n_estimators=50, learning_rate=0.05, num_leaves=15, max_depth=4,
                         random_state=SEED, verbose=-1, n_jobs=-1)
clf.fit(X_tr, y_tr)
calibrated = CalibratedClassifierCV(clf, method=’sigmoid’, cv=5)
calibrated.fit(X_tr, y_tr)
probs = calibrated.predict_proba(X_te)[:, 1]

print(f”Accuracy = {accuracy_score(y_te, probs >= 0.5)*100:.2f}%”)
print(f”ROC-AUC  = {roc_auc_score(y_te, probs):.4f}”)
print(f”PR-AUC   = {average_precision_score(y_te, probs):.4f}”)
print(f”Brier    = {brier_score_loss(y_te, probs):.6f}”)

# ———- SHAP ATTRIBUTION ———-
explainer = shap.TreeExplainer(clf)
shap_vals = explainer.shap_values(X_te)
if isinstance(shap_vals, list):
    shap_vals = shap_vals[1]
elif shap_vals.ndim == 3:
    shap_vals = shap_vals[:, :, 1]

mean_abs_shap = np.mean(np.abs(shap_vals), axis=0)
ranked_idx = np.argsort(mean_abs_shap)
print(“Top 5 satisfaction drivers (mean |SHAP|):”)
for i in ranked_idx[::-1][:5]:
    print(f”  {features[i]:35s} {mean_abs_shap[i]:.4f}”)

# Decision Curve Analysis (DCA) for enterprise license procurement
thresholds = np.linspace(0.10, 0.60, 40)
n = len(y_te)
nb_model, nb_all = [], []
for th in thresholds:
    pred_pos = probs >= th
    tp = np.sum((pred_pos == 1) & (y_te == 1))
    fp = np.sum((pred_pos == 1) & (y_te == 0))
    nb_model.append(tp/n – fp/n * th/(1-th))
    nb_all.append(np.sum(y_te == 1)/n – np.sum(y_te == 0)/n * th/(1-th))

print(f”DCA positive-net-benefit range: {min(th for th, nb in zip(thresholds, nb_model) if nb > 0):.2f} – {max(th for th, nb in zip(thresholds, nb_model) if nb > 0):.2f}”)

ML Blog · 300 AI Users Benchmarked

Do AI Subscriptions
Actually Save Time?