Data Science e ML Clássico

"""
A/B Test completo de uma feature de checkout.
Variante A (controle): checkout em 3 passos.
Variante B (teste): checkout em 1 passo.
Métrica primária: conversão (binária).
"""
import numpy as np
from scipy import stats
from statsmodels.stats.power import zt_ind_solve_power
from statsmodels.stats.proportion import proportions_ztest, confint_proportions_2indep

# ─── Passo 1: Calcular sample size ANTES de rodar o teste ──────────────────
# Você quer detectar uplift de 1.5pp sobre baseline de 12% (relative ~12.5%)
baseline_rate = 0.12          # conversão atual
mde_absolute = 0.015          # 1.5 ponto percentual de melhoria
alpha = 0.05                  # nível de significância
power = 0.80                  # poder estatístico (1 - beta)

# Cohen's h — effect size para proporções
p1, p2 = baseline_rate, baseline_rate + mde_absolute
effect_size = 2 * (np.arcsin(np.sqrt(p2)) - np.arcsin(np.sqrt(p1)))

n_por_grupo = zt_ind_solve_power(
    effect_size=effect_size,
    alpha=alpha,
    power=power,
    alternative='two-sided'
)
print(f"📐 Sample size necessário: {int(np.ceil(n_por_grupo)):,} usuários por grupo")
# → ~7,200 por grupo (14,400 total)

# ─── Passo 2: Simular dados do teste (na vida real, viriam do warehouse) ───
np.random.seed(42)
n_a = 7200
n_b = 7200
conversoes_a = np.random.binomial(1, 0.120, n_a)  # 12.0% conversão A
conversoes_b = np.random.binomial(1, 0.138, n_b)  # 13.8% conversão B

# ─── Passo 3: Sample Ratio Mismatch check ──────────────────────────────────
# Detecta bug de assignment ANTES de olhar a métrica
chi2, p_srm = stats.chisquare([n_a, n_b], f_exp=[(n_a+n_b)/2]*2)
if p_srm < 0.001:
    raise RuntimeError(f"⚠️ SRM detectado (p={p_srm:.4f}) — há bug no split. NÃO interprete o teste.")
print(f"✓ SRM check passou (p={p_srm:.3f})")

# ─── Passo 4: Teste de proporções (z-test) ─────────────────────────────────
sucessos = np.array([conversoes_a.sum(), conversoes_b.sum()])
amostras = np.array([n_a, n_b])
z_stat, p_valor = proportions_ztest(sucessos, amostras, alternative='two-sided')

# Intervalo de confiança 95% para a DIFERENÇA de proporções
ci_low, ci_high = confint_proportions_2indep(
    sucessos[1], n_b, sucessos[0], n_a,
    method='wald', compare='diff', alpha=0.05
)

# ─── Passo 5: Reportar resultado de forma honesta ──────────────────────────
taxa_a = sucessos[0] / n_a
taxa_b = sucessos[1] / n_b
uplift_abs = taxa_b - taxa_a
uplift_rel = uplift_abs / taxa_a * 100

print(f"\n📊 Resultados:")
print(f"  Variante A: {taxa_a:.4f} ({sucessos[0]:,}/{n_a:,})")
print(f"  Variante B: {taxa_b:.4f} ({sucessos[1]:,}/{n_b:,})")
print(f"  Uplift absoluto: {uplift_abs:+.4f} ({uplift_rel:+.2f}%)")
print(f"  IC 95% para diferença: [{ci_low:+.4f}, {ci_high:+.4f}]")
print(f"  z-stat: {z_stat:.3f}, p-valor: {p_valor:.4f}")

# Conclusão honesta — IC e p-value, não só p-value
if p_valor < alpha and ci_low > 0:
    print(f"\n✅ Variante B vence com significância estatística (p={p_valor:.4f}).")
    print(f"   Decisão: rollout 100% para B.")
elif p_valor < alpha and ci_high < 0:
    print(f"\n❌ Variante B é PIOR que A com significância (p={p_valor:.4f}).")
    print(f"   Decisão: matar a feature.")
else:
    print(f"\n🤷 Inconclusivo (p={p_valor:.4f}). IC inclui 0.")
    print(f"   Decisão: rodar mais tempo OU aceitar que efeito é <{mde_absolute*100}pp.")

"""
Pipeline sklearn que evita data leakage em features de scaling/encoding.
Cross-Validation estratificada — preserva proporção de classes nos folds.
"""
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
import pandas as pd
import numpy as np

# Suponha que df tem features 'idade', 'salario' (numéricas), 'cidade', 'plano' (cat)
df = pd.read_csv("clientes.csv")
X = df.drop(columns=["churn"])
y = df["churn"]

num_features = ["idade", "salario", "tempo_casa_meses"]
cat_features = ["cidade", "plano", "canal_aquisicao"]

# Preprocessing por tipo de feature — fit feito DENTRO do CV, não antes
preprocessor = ColumnTransformer([
    ("num", StandardScaler(), num_features),
    ("cat", OneHotEncoder(handle_unknown="ignore", sparse_output=False), cat_features),
])

# Pipeline garante que scaling/encoding é fitado SÓ no train de cada fold
pipe = Pipeline([
    ("prep", preprocessor),
    ("clf", LogisticRegression(max_iter=1000, class_weight="balanced", C=1.0)),
])

# Stratified K-Fold preserva proporção de churn em cada fold
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(pipe, X, y, scoring="roc_auc", cv=cv, n_jobs=-1)

print(f"AUC por fold: {scores}")
print(f"AUC média: {scores.mean():.4f} ± {scores.std():.4f}")
# → AUC média: 0.7842 ± 0.0123  (modelo decente; XGBoost geralmente atinge 0.85+)

"""
End-to-end churn prediction com XGBoost.
Inclui: load → EDA → feature engineering → train → evaluate → save.
"""
import pandas as pd
import numpy as np
import xgboost as xgb
import pickle
from sklearn.model_selection import train_test_split
from sklearn.metrics import (
    roc_auc_score, f1_score, classification_report,
    confusion_matrix, precision_recall_curve
)
from sklearn.preprocessing import LabelEncoder

# ─── 1) Carregar dados ─────────────────────────────────────────────────────
df = pd.read_csv("telecom_churn.csv")
print(f"📂 Dataset: {df.shape[0]:,} linhas × {df.shape[1]} colunas")
print(f"🎯 Taxa de churn: {df['churn'].mean()*100:.2f}%")  # esperado ~14%

# ─── 2) EDA básico — sanity checks que evitam dor depois ───────────────────
print("\n📊 Tipos de dados:")
print(df.dtypes.value_counts())

print("\n🔍 Valores ausentes (top 5):")
print(df.isnull().sum().sort_values(ascending=False).head())

print("\n📈 Estatísticas das numéricas:")
print(df.describe(include=[np.number]).T[['mean', 'std', 'min', 'max']])

# Detectar colunas com alta cardinalidade que podem ser problemáticas
for col in df.select_dtypes(include='object').columns:
    n_unique = df[col].nunique()
    if n_unique > 50:
        print(f"⚠️  {col} tem {n_unique} valores únicos — considerar target encoding")

# ─── 3) Feature Engineering ────────────────────────────────────────────────
# Datetime: dias desde último contato → numérico
df['data_ultimo_contato'] = pd.to_datetime(df['data_ultimo_contato'])
df['dias_desde_contato'] = (pd.Timestamp.now() - df['data_ultimo_contato']).dt.days
df = df.drop(columns=['data_ultimo_contato'])

# Razões úteis (feature engineering manual ainda bate AutoML em domínio conhecido)
df['gasto_por_minuto'] = df['valor_fatura_brl'] / (df['minutos_uso_mes'] + 1)
df['chamados_por_mes'] = df['total_chamados_suporte'] / (df['tempo_casa_meses'] + 1)
df['tem_atraso'] = (df['dias_atraso_pagamento'] > 0).astype(int)

# Categóricas: encoding (XGBoost >=1.6 lida com cat nativamente, mas LabelEncoder é simples)
cat_cols = ['plano', 'cidade', 'canal_aquisicao', 'forma_pagamento']
encoders = {}
for col in cat_cols:
    le = LabelEncoder()
    df[col] = le.fit_transform(df[col].astype(str))
    encoders[col] = le

# ─── 4) Split temporal (NÃO shuffle — churn é temporal) ────────────────────
df = df.sort_values('mes_referencia')
split_idx = int(len(df) * 0.8)
df_train = df.iloc[:split_idx]
df_test = df.iloc[split_idx:]

X_train = df_train.drop(columns=['churn', 'cliente_id', 'mes_referencia'])
y_train = df_train['churn']
X_test = df_test.drop(columns=['churn', 'cliente_id', 'mes_referencia'])
y_test = df_test['churn']

print(f"\n🔧 Train: {len(X_train):,} | Test: {len(X_test):,}")
print(f"   Churn rate train: {y_train.mean()*100:.2f}% | test: {y_test.mean()*100:.2f}%")

# ─── 5) Treinar XGBoost com early stopping ────────────────────────────────
# scale_pos_weight = ratio neg/pos — compensa desbalanceamento
scale_pos = (y_train == 0).sum() / (y_train == 1).sum()

modelo = xgb.XGBClassifier(
    n_estimators=500,
    max_depth=6,
    learning_rate=0.05,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0.1,           # L1
    reg_lambda=1.0,          # L2
    scale_pos_weight=scale_pos,
    eval_metric='auc',
    early_stopping_rounds=30,
    tree_method='hist',      # mais rápido que 'exact'
    random_state=42,
    n_jobs=-1,
)

# Holdout interno para early stopping (não vaza o test set)
X_tr, X_val, y_tr, y_val = train_test_split(
    X_train, y_train, test_size=0.15, stratify=y_train, random_state=42
)
modelo.fit(X_tr, y_tr, eval_set=[(X_val, y_val)], verbose=False)
print(f"\n✓ Treinado. Best iteration: {modelo.best_iteration}")

# ─── 6) Avaliar no test set ────────────────────────────────────────────────
proba_test = modelo.predict_proba(X_test)[:, 1]
pred_test = (proba_test >= 0.5).astype(int)

auc = roc_auc_score(y_test, proba_test)
f1 = f1_score(y_test, pred_test)

print(f"\n📊 Performance no test set:")
print(f"   AUC: {auc:.4f}")
print(f"   F1:  {f1:.4f}")
print(f"\n{classification_report(y_test, pred_test, target_names=['ativo', 'churn'])}")
print(f"Confusion Matrix:\n{confusion_matrix(y_test, pred_test)}")

# Top-15 features mais importantes (gain)
importance = pd.DataFrame({
    'feature': X_train.columns,
    'gain': modelo.feature_importances_
}).sort_values('gain', ascending=False).head(15)
print(f"\n🎯 Top-15 features por gain:\n{importance.to_string(index=False)}")

# ─── 7) Salvar modelo + artefatos para produção ───────────────────────────
artefato = {
    'modelo': modelo,
    'encoders': encoders,
    'feature_order': list(X_train.columns),
    'metadata': {
        'auc_test': auc,
        'f1_test': f1,
        'train_size': len(X_train),
        'churn_rate_train': float(y_train.mean()),
        'data_treino': pd.Timestamp.now().isoformat(),
        'xgboost_version': xgb.__version__,
    }
}

with open('churn_model_v1.pkl', 'wb') as f:
    pickle.dump(artefato, f)

print("\n💾 Modelo salvo em churn_model_v1.pkl")
print(f"   Tamanho: ~{round(len(pickle.dumps(artefato))/1024, 1)} KB")

"""
Treina modelo, registra no MLflow e promove para 'Production' apenas
se AUC > baseline atual. Padrão usado em pipelines GitHub Actions.
"""
import mlflow
import mlflow.xgboost
import xgboost as xgb
from mlflow.tracking import MlflowClient
from sklearn.metrics import roc_auc_score, f1_score

mlflow.set_tracking_uri("http://mlflow.empresa.com:5000")
mlflow.set_experiment("churn-telecom")

MODEL_NAME = "churn_telecom"

def treinar_e_registrar(X_train, y_train, X_test, y_test, params: dict):
    with mlflow.start_run() as run:
        # Log params automaticamente
        mlflow.log_params(params)
        mlflow.log_param("dataset_hash", "sha256:abc123...")  # de DVC
        mlflow.log_param("commit_sha", "git rev-parse HEAD")

        # Treina
        model = xgb.XGBClassifier(**params, eval_metric='auc', random_state=42)
        model.fit(X_train, y_train)

        # Avalia
        proba = model.predict_proba(X_test)[:, 1]
        pred = (proba >= 0.5).astype(int)
        auc = roc_auc_score(y_test, proba)
        f1 = f1_score(y_test, pred)

        mlflow.log_metric("auc_test", auc)
        mlflow.log_metric("f1_test", f1)

        # Salva modelo no Model Registry
        mlflow.xgboost.log_model(
            model,
            artifact_path="model",
            registered_model_name=MODEL_NAME,
        )
        return run.info.run_id, auc

def promover_se_melhor(run_id: str, auc_novo: float, threshold: float = 0.005):
    """
    Promove para Production apenas se ganho > threshold sobre o atual.
    Evita 'noise promotions' — pequenas variações de CV.
    """
    client = MlflowClient()
    versoes = client.get_latest_versions(MODEL_NAME, stages=["Production"])

    if versoes:
        prod_run = client.get_run(versoes[0].run_id)
        auc_prod = prod_run.data.metrics["auc_test"]
        ganho = auc_novo - auc_prod
        print(f"AUC atual em prod: {auc_prod:.4f} | AUC novo: {auc_novo:.4f} | Ganho: {ganho:+.4f}")

        if ganho < threshold:
            print(f"❌ Ganho < {threshold} — NÃO promovendo. Mantendo modelo atual em prod.")
            return False

    # Encontra a versão recém-registrada
    nova_versao = client.search_model_versions(f"run_id='{run_id}'")[0]

    # Move atual para Archived, novo para Production
    if versoes:
        client.transition_model_version_stage(
            name=MODEL_NAME, version=versoes[0].version, stage="Archived"
        )
    client.transition_model_version_stage(
        name=MODEL_NAME, version=nova_versao.version, stage="Production"
    )
    print(f"✅ Modelo v{nova_versao.version} promovido para Production")
    return True

# Uso típico em CI:
params = {"n_estimators": 500, "max_depth": 6, "learning_rate": 0.05}
run_id, auc = treinar_e_registrar(X_train, y_train, X_test, y_test, params)
promover_se_melhor(run_id, auc)

"""
Classificação de prioridade de ticket de suporte.
Combina: texto do ticket (via OpenAI embeddings) + features de cliente.
Resultado: XGBoost prevê P(prioridade=alta).
"""
import numpy as np
import pandas as pd
import xgboost as xgb
from openai import OpenAI
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score, classification_report

client = OpenAI()  # OPENAI_API_KEY no env

# ─── 1) Carregar dataset de tickets ────────────────────────────────────────
df = pd.read_csv("tickets_suporte.csv")
# Colunas: ticket_id, texto, cliente_id, plano, tempo_casa_meses,
#         tickets_abertos_30d, prioridade_alta (target)

# ─── 2) Calcular embeddings em batch (cache em produção) ──────────────────
def embed_batch(textos: list[str], model: str = "text-embedding-3-small") -> np.ndarray:
    """Embeddings da OpenAI em batch — 1536 dimensões."""
    resp = client.embeddings.create(input=textos, model=model)
    return np.array([d.embedding for d in resp.data])

# Em produção: pré-calcule e cache em vector DB (Pinecone, pgvector)
print("📡 Gerando embeddings...")
batch_size = 100
embeddings = []
for i in range(0, len(df), batch_size):
    batch = df["texto"].iloc[i:i+batch_size].tolist()
    embeddings.append(embed_batch(batch))
emb_full = np.vstack(embeddings)
print(f"✓ Shape dos embeddings: {emb_full.shape}")  # (N, 1536)

# ─── 3) Reduzir dimensionalidade (1536 → 32) com PCA ──────────────────────
# Por que? XGBoost com 1536 dims sofre da maldição de dimensionalidade.
# 32 dims preservam ~85% da variância para domínio textual fechado.
pca = PCA(n_components=32, random_state=42)
emb_reduced = pca.fit_transform(emb_full)
print(f"✓ Variância preservada com 32d: {pca.explained_variance_ratio_.sum():.2%}")

# ─── 4) Concatenar com features tabulares ─────────────────────────────────
features_tab = df[["plano", "tempo_casa_meses", "tickets_abertos_30d"]].values
features_tab[:, 0] = pd.factorize(features_tab[:, 0])[0]  # encode plano

X = np.hstack([features_tab, emb_reduced])  # (N, 3 + 32) = (N, 35)
y = df["prioridade_alta"].values

# ─── 5) Train + Eval ──────────────────────────────────────────────────────
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)

modelo = xgb.XGBClassifier(
    n_estimators=300, max_depth=5, learning_rate=0.05,
    eval_metric='auc', random_state=42,
)
modelo.fit(X_tr, y_tr)
auc = roc_auc_score(y_te, modelo.predict_proba(X_te)[:, 1])
print(f"\n📊 AUC (híbrido emb+tab): {auc:.4f}")

# Comparação: só features tabulares (sem embedding)
modelo_tab = xgb.XGBClassifier(n_estimators=300, max_depth=5, random_state=42)
modelo_tab.fit(X_tr[:, :3], y_tr)
auc_tab = roc_auc_score(y_te, modelo_tab.predict_proba(X_te[:, :3])[:, 1])
print(f"📊 AUC (só tabular):     {auc_tab:.4f}")
print(f"📈 Ganho do embedding:    {auc - auc_tab:+.4f}")

# Em produção, esperado: ganho de 0.05 a 0.12 em AUC adicionando texto.