2.3 - Modelo Baseline

# Carregar dados
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, roc_curve, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

import warnings
warnings.filterwarnings('ignore')

# Carregar dataset com features de engenharia
df = pd.read_csv("credit_risk_features_engineered.csv")
print(f"✅ Dataset carregado: {len(df):,} registros × {df.shape[1]} features")

# Explorar features disponíveis
print("🔍 EXPLORAÇÃO DAS FEATURES DISPONÍVEIS")
print("=" * 60)

print(f"\n📊 Informações gerais:")
print(f"  - Total de features: {df.shape[1]}")
print(f"  - Total de registros: {len(df):,}")

# Separar todas as colunas (exceto target)
all_cols = [col for col in df.columns if col != 'default']
numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
categorical_cols = df.select_dtypes(include=['object']).columns.tolist()

# Remover target das numéricas
if 'default' in numeric_cols:
    numeric_cols.remove('default')

print(f"\n📊 Tipos de features:")
print(f"  - Numéricas: {len(numeric_cols)}")
print(f"  - Categóricas: {len(categorical_cols)}")
print(f"  - Target: 1 (default)")

# Identificar features originais, derivadas e one-hot
features_originais = ["idade", "renda", "score_credito", "tempo_emprego", "valor_emprestimo", 
                      "prazo_emprestimo", "tipo_residencia"]
features_derivadas = ["razao_emprestimo_renda", "comprometimento_mensal", "e_jovem", "score_normalizado"]

# Features one-hot (começam com genero_, estado_civil_, tipo_emprego_, regiao_)
features_onehot = [col for col in all_cols if any(col.startswith(prefix) for prefix in 
                   ["genero_", "estado_civil_", "tipo_emprego_", "regiao_"])]

# Features que não se encaixam nas categorias acima
features_outras = [col for col in all_cols if col not in features_originais 
                   and col not in features_derivadas and col not in features_onehot]

print(f"\n📋 Categorização das features:")
print(f"  - Features originais: {len([f for f in features_originais if f in all_cols])}")
print(f"  - Features derivadas: {len([f for f in features_derivadas if f in all_cols])}")
print(f"  - Features One-Hot Encoding: {len(features_onehot)}")
print(f"  - Outras features: {len(features_outras)}")

# Mostrar exemplos de cada categoria
print(f"\n📋 Exemplos de features originais:")
for col in features_originais[:5]:
    if col in all_cols:
        print(f"  ✅ {col}")

print(f"\n📋 Features derivadas:")
for col in features_derivadas:
    if col in all_cols:
        print(f"  ✅ {col}")

print(f"\n📋 Exemplos de features One-Hot ({len(features_onehot)} no total):")
for col in features_onehot[:10]:
    print(f"  ✅ {col}")
if len(features_onehot) > 10:
    print(f"  ... e mais {len(features_onehot) - 10} features One-Hot")

# Verificar variável target
if 'default' in df.columns:
    print(f"\n✅ Variável target encontrada: 'default'")
    print(f"   - Taxa de default: {df['default'].mean():.2%}")
    print(f"   - Total de defaults: {df['default'].sum():,}")
else:
    print(f"\n⚠️  Variável target 'default' não encontrada!")

# Visualizar a base de dados
print("👀 VISUALIZAÇÃO DA BASE DE DADOS")
print("=" * 60)

print(f"\n📊 Primeiras 10 linhas do dataset:")
print(df.head())

print(f"\n📊 Informações sobre as colunas:")
print(f"  - Total de colunas: {df.shape[1]}")
print(f"  - Total de linhas: {len(df):,}")

# Mostrar estatísticas descritivas básicas
print(f"\n📊 Estatísticas descritivas (primeiras features numéricas):")
numeric_cols_basic = ["idade", "renda", "score_credito", "tempo_emprego", "valor_emprestimo", "prazo_emprestimo"]
cols_disponiveis = [col for col in numeric_cols_basic if col in df.columns]
if cols_disponiveis:
    print(df[cols_disponiveis].describe())

# Selecionar features para o modelo baseline
print("🔧 SELEÇÃO DE FEATURES PARA MODELO BASELINE")
print("=" * 60)

# Para o modelo baseline, vamos usar features básicas e importantes
feature_cols = ["renda", "tempo_emprego", "valor_emprestimo", "prazo_emprestimo"]

# Verificar quais features estão disponíveis
features_disponiveis = [col for col in feature_cols if col in df.columns]
features_faltando = [col for col in feature_cols if col not in df.columns]

print(f"\n📋 Features selecionadas para o modelo baseline:")
for col in features_disponiveis:
    print(f"  ✅ {col}")

if features_faltando:
    print(f"\n⚠️  Features não encontradas: {features_faltando}")

# Preparar dados
X = df[features_disponiveis].copy()
y = df["default"].copy()

# Remover valores ausentes
X_limpo = X.dropna()
y_limpo = y[X_limpo.index]

print(f"\n✅ Dados preparados:")
print(f"   - Features selecionadas: {len(features_disponiveis)}")
print(f"   - Registros válidos: {len(X_limpo):,}")
print(f"   - Taxa de default: {y_limpo.mean():.2%}")

# Dividir em treino e teste
X_train, X_test, y_train, y_test = train_test_split(
    X_limpo, y_limpo, test_size=0.2, random_state=42, stratify=y_limpo
)

print(f"📊 Treino: {X_train.shape[0]:,} amostras")
print(f"📊 Teste: {X_test.shape[0]:,} amostras")
print(f"📊 Taxa default treino: {y_train.mean():.2%}")
print(f"📊 Taxa default teste: {y_test.mean():.2%}")

# Treinar modelo
modelo = LogisticRegression(random_state=42, max_iter=1000)
modelo.fit(X_train, y_train)
print("✅ Modelo treinado!")

# Calcular p-valores usando statsmodels
import statsmodels.api as sm

# Preparar dados para statsmodels (adiciona intercepto)
X_train_sm = sm.add_constant(X_train)
logit_model = sm.Logit(y_train, X_train_sm)
result = logit_model.fit(disp=0)

# Obter p-valores
p_values = result.pvalues[1:]  # Remove o intercepto

# Calcular importância relativa (valor absoluto normalizado)
coef_abs = np.abs(modelo.coef_[0])
importancia_relativa = (coef_abs / coef_abs.sum()) * 100

# Calcular Odds Ratio (exponencial dos coeficientes)
odds_ratio = np.exp(modelo.coef_[0])

# Mostrar informações do modelo
print("\n📊 Informações Detalhadas do Modelo:")
print("=" * 80)
print(f"{'Feature':<20} {'Coeficiente':<15} {'P-valor':<15} {'Importância %':<15} {'Odds Ratio':<15}")
print("-" * 80)

for i, col in enumerate(features_disponiveis):
    p_val = p_values[i]
    significancia = "***" if p_val < 0.001 else "**" if p_val < 0.01 else "*" if p_val < 0.05 else ""
    print(f"{col:<20} {modelo.coef_[0][i]:>14.4f} {p_val:>14.4f}{significancia:<1} {importancia_relativa[i]:>14.2f}% {odds_ratio[i]:>14.4f}")

print("\nLegenda de significância:")
print("  *** p < 0.001 (altamente significativo)")
print("  **  p < 0.01  (muito significativo)")
print("  *   p < 0.05  (significativo)")
print("  (sem *) p >= 0.05 (não significativo)")

# Resumo estatístico
print(f"\n📊 Resumo Estatístico:")
print(f"  - Features significativas (p < 0.05): {sum(p_values < 0.05)}/{len(features_disponiveis)}")
print(f"  - Feature mais importante: {features_disponiveis[np.argmax(importancia_relativa)]} ({importancia_relativa.max():.2f}%)")
print(f"  - Feature menos importante: {features_disponiveis[np.argmin(importancia_relativa)]} ({importancia_relativa.min():.2f}%)")

# Predições
y_pred_proba = modelo.predict_proba(X_test)[:, 1]
y_pred = modelo.predict(X_test)

print("✅ Predições realizadas!")
print(f"📊 Probabilidade média: {y_pred_proba.mean():.4f}")
print(f"📊 Predições classe 1: {y_pred.sum():,}")

# Avaliação do modelo

print("📊 AVALIAÇÃO DO MODELO BASELINE")
print("=" * 60)

# Predições para treino e teste
y_train_pred = modelo.predict(X_train)
y_train_proba = modelo.predict_proba(X_train)[:, 1]
y_test_pred = modelo.predict(X_test)
y_test_proba = modelo.predict_proba(X_test)[:, 1]

# Métricas para treino
acc_train = accuracy_score(y_train, y_train_pred)
prec_train = precision_score(y_train, y_train_pred, zero_division=0)
rec_train = recall_score(y_train, y_train_pred, zero_division=0)
f1_train = f1_score(y_train, y_train_pred, zero_division=0)
roc_auc_train = roc_auc_score(y_train, y_train_proba)

# Métricas para teste
acc_test = accuracy_score(y_test, y_test_pred)
prec_test = precision_score(y_test, y_test_pred, zero_division=0)
rec_test = recall_score(y_test, y_test_pred, zero_division=0)
f1_test = f1_score(y_test, y_test_pred, zero_division=0)
roc_auc_test = roc_auc_score(y_test, y_test_proba)

# Mostrar métricas
print("\n📊 Métricas de Avaliação:")
print(f"\n{'Métrica':<20} {'Treino':<15} {'Teste':<15}")
print("-" * 50)
print(f"{'Acurácia':<20} {acc_train:<15.4f} {acc_test:<15.4f}")
print(f"{'Precisão':<20} {prec_train:<15.4f} {prec_test:<15.4f}")
print(f"{'Recall':<20} {rec_train:<15.4f} {rec_test:<15.4f}")
print(f"{'F1-Score':<20} {f1_train:<15.4f} {f1_test:<15.4f}")
print(f"{'ROC-AUC':<20} {roc_auc_train:<15.4f} {roc_auc_test:<15.4f}")

# Curvas ROC
fpr_train, tpr_train, _ = roc_curve(y_train, y_train_proba)
fpr_test, tpr_test, _ = roc_curve(y_test, y_test_proba)

plt.figure(figsize=(12, 5))

# Curva ROC - Treino
plt.subplot(1, 2, 1)
plt.plot(fpr_train, tpr_train, label=f'Treino (AUC = {roc_auc_train:.4f})', linewidth=2)
plt.plot([0, 1], [0, 1], 'k--', label='Classificador Aleatório')
plt.xlabel('Taxa de Falsos Positivos (FPR)')
plt.ylabel('Taxa de Verdadeiros Positivos (TPR)')
plt.title('Curva ROC - Treino')
plt.legend()
plt.grid(alpha=0.3)

# Curva ROC - Teste
plt.subplot(1, 2, 2)
plt.plot(fpr_test, tpr_test, label=f'Teste (AUC = {roc_auc_test:.4f})', linewidth=2, color='orange')
plt.plot([0, 1], [0, 1], 'k--', label='Classificador Aleatório')
plt.xlabel('Taxa de Falsos Positivos (FPR)')
plt.ylabel('Taxa de Verdadeiros Positivos (TPR)')
plt.title('Curva ROC - Teste')
plt.legend()
plt.grid(alpha=0.3)

plt.tight_layout()
plt.show()

# Matriz de Confusão
cm = confusion_matrix(y_test, y_test_pred)

plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=True)
plt.title('Matriz de Confusão - Teste')
plt.ylabel('Valor Real')
plt.xlabel('Valor Predito')
plt.show()

# Mostrar valores da matriz de confusão
print("\n📊 Matriz de Confusão (Teste):")
print(f"  Verdadeiros Negativos (TN): {cm[0,0]:,}")
print(f"  Falsos Positivos (FP): {cm[0,1]:,}")
print(f"  Falsos Negativos (FN): {cm[1,0]:,}")
print(f"  Verdadeiros Positivos (TP): {cm[1,1]:,}")