ajustes

requirements.txt

@@ -1,3 +1,6 @@
-altair
-pandas
-streamlit
+streamlit==1.39.0
+pandas==2.2.3
+numpy==1.26.4
+scikit-learn==1.5.2
+altair==5.4.1
+statsmodels==0.14.4

src/streamlit_app.py

@@ -1,40 +1,382 @@
-import altair as alt
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# App: Análise de Reclamações de Consumidores
+# Dataset esperado: Dados/marketing_campaign.csv  (Kaggle - Customer Personality Analysis)
+# Objetivo: prever probabilidade de "Complain" e explicar fatores (itens c e e da Tarefa)
+# ------------------------------------------------------------
+import os
 import numpy as np
 import pandas as pd
 import streamlit as st
+import altair as alt
+
+from typing import List, Tuple
+
+# Sci-kit / stats
+from sklearn.model_selection import train_test_split
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from sklearn.pipeline import Pipeline
+from sklearn.impute import SimpleImputer
+from sklearn.metrics import roc_auc_score, accuracy_score, confusion_matrix, RocCurveDisplay
+from sklearn.inspection import permutation_importance
+
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+
+import statsmodels.api as sm
+
+# -----------------------------
+# Configurações gerais
+# -----------------------------
+st.set_page_config(
+    page_title="Reclamações de Consumidores — PPCA/UnB",
+    layout="wide",
+)
+
+st.title("📈 Reclamações de Consumidores — Predição & Explicação")
+st.caption("Com base no conjunto **Customer Personality Analysis** (marketing_campaign.csv)")
+
+DATA_PATH = "Dados/marketing_campaign.csv"
+
+# -----------------------------
+# Utilitários
+# -----------------------------
+@st.cache_data(show_spinner=False)
+def load_data(path: str) -> pd.DataFrame:
+    df = pd.read_csv(path, sep=",", encoding="utf-8")
+    # Alguns CSVs deste dataset vêm com separador ';'. Se falhar, tenta novamente:
+    if df.shape[1] == 1:
+        df = pd.read_csv(path, sep=";", encoding="utf-8")
+    return df
+
+def infer_target_column(df: pd.DataFrame) -> str:
+    # No dataset da Kaggle, a variável é "Complain" (0/1).
+    # Se não existir, tenta nomes comuns.
+    candidates = ["Complain", "complain", "Complaint", "has_complaint", "has_complain"]
+    for c in candidates:
+        if c in df.columns:
+            return c
+    # fallback: se não achou, cria guiagem
+    return None
+
+def split_features(df: pd.DataFrame, y_col: str) -> Tuple[List[str], List[str]]:
+    cat_cols = [c for c in df.columns if (df[c].dtype == "object" or df[c].dtype.name == "category") and c != y_col]
+    num_cols = [c for c in df.columns if (np.issubdtype(df[c].dtype, np.number)) and c != y_col]
+    return num_cols, cat_cols
+
+def build_preprocessor(num_cols: List[str], cat_cols: List[str]) -> ColumnTransformer:
+    num_pipe = Pipeline([
+        ("imputer", SimpleImputer(strategy="median")),
+        ("scaler", StandardScaler())
+    ])
+    cat_pipe = Pipeline([
+        ("imputer", SimpleImputer(strategy="most_frequent")),
+        ("onehot", OneHotEncoder(handle_unknown="ignore", sparse_output=False))
+    ])
+    pre = ColumnTransformer([
+        ("num", num_pipe, num_cols),
+        ("cat", cat_pipe, cat_cols)
+    ])
+    return pre
+
+def get_model(name: str):
+    if name == "Regressão Logística":
+        return LogisticRegression(max_iter=200, n_jobs=None)  # n_jobs só no liblinear/saga; usamos solver padrão (lbfgs)
+    elif name == "Random Forest":
+        return RandomForestClassifier(
+            n_estimators=300,
+            max_depth=None,
+            random_state=42,
+            n_jobs=-1
+        )
+    else:
+        raise ValueError("Modelo desconhecido.")
+
+def coefficient_table_for_logit(statsmodels_result, feature_names):
+    # Retorna DataFrame com OR e IC 95%
+    params = statsmodels_result.params
+    conf = statsmodels_result.conf_int(alpha=0.05)
+    df_coef = pd.DataFrame({
+        "feature": ["Intercept"] + feature_names,
+        "coef": params.values
+    })
+    conf = pd.DataFrame(conf.values, columns=["ci_low", "ci_high"])
+    df_coef["ci_low"] = conf["ci_low"].values
+    df_coef["ci_high"] = conf["ci_high"].values
+
+    # Odds ratios
+    df_coef["odds_ratio"] = np.exp(df_coef["coef"])
+    df_coef["or_ci_low"] = np.exp(df_coef["ci_low"])
+    df_coef["or_ci_high"] = np.exp(df_coef["ci_high"])
+    return df_coef
+
+def make_recommendations(imp_df: pd.DataFrame, top_k: int = 5) -> List[str]:
+    """
+    Gera recomendações de alto nível com base nas variáveis mais importantes.
+    imp_df precisa ter colunas: feature, importance, sign (para regressão logística; senão assume neutro).
+    """
+    recs = []
+    # Pega top_k
+    core = imp_df.sort_values("importance", ascending=False).head(top_k)
+    for _, row in core.iterrows():
+        feat = row["feature"]
+        sign = row.get("sign", 0)
+        if sign > 0:
+            recs.append(
+                f"🔧 **Reduzir a exposição associada a `{feat}`**, pois aumento nessa variável eleva a probabilidade de reclamação. "
+                f"Considere políticas específicas (p.ex., comunicação proativa, revisão de políticas de entrega/atendimento, "
+                f"ou benefícios segmentados para o grupo impactado por `{feat}`)."
+            )
+        elif sign < 0:
+            recs.append(
+                f"✅ **Ampliar ações relacionadas a `{feat}`**, já que maior valor nessa variável tende a reduzir reclamações. "
+                f"Ex.: expandir programas de fidelidade ou incentivos que reforcem o comportamento ligado a `{feat}`."
+            )
+        else:
+            recs.append(
+                f"📌 **Monitorar `{feat}`** de perto: é importante, ainda que a direção do efeito varie entre segmentos. "
+                f"Teste intervenções com experimentos A/B e avalie impacto nas métricas de reclamação."
+            )
+    # Recomendações genéricas de processo:
+    recs.append("🧪 **Implantar testes A/B** para validar intervenções nas variáveis-chave e medir impacto em taxa de reclamação.")
+    recs.append("📞 **Aprimorar o 1º contato (FCR)**: reduzir transferência/recontato; scripts e treinamentos focados nas causas top-1/2.")
+    recs.append("🔁 **Feedback loop**: alimentar o time de Produto/Qualidade com causas de reclamação mais preditivas para correções upstream.")
+    return recs
+
+# -----------------------------
+# Carregamento
+# -----------------------------
+with st.sidebar:
+    st.header("📂 Dados")
+    st.write("Esperado: `Dados/marketing_campaign.csv`")
+    if not os.path.exists(DATA_PATH):
+        st.error(f"Arquivo não encontrado em `{DATA_PATH}`. Suba o CSV na pasta `Dados/` do Space.")
+    else:
+        st.success("Arquivo encontrado ✅")
+
+try:
+    df_raw = load_data(DATA_PATH)
+except Exception as e:
+    st.stop()
+
+target_col = infer_target_column(df_raw)
+if target_col is None:
+    st.error("Não encontrei a coluna alvo (ex.: `Complain`). Confirme o nome no CSV.")
+    st.dataframe(df_raw.head())
+    st.stop()
+
+# -----------------------------
+# Sidebar — Configuração
+# -----------------------------
+with st.sidebar:
+    st.header("⚙️ Configuração do Modelo")
+    st.caption("**Item (c)** — Definição & Seleção de Modelos")
+    model_name = st.selectbox("Modelo preditivo", ["Regressão Logística", "Random Forest"], index=0)
+
+    # Seleção de variáveis explicativas
+    st.subheader("Variáveis explicativas")
+    num_cols, cat_cols = split_features(df_raw, target_col)
+    all_feats = num_cols + cat_cols
+    default_feats = [c for c in all_feats if c != target_col]
+    selected_feats = st.multiselect(
+        "Selecione as variáveis de entrada",
+        options=default_feats,
+        default=default_feats[: min(12, len(default_feats))]
+    )
+
+    test_size = st.slider("Proporção de teste", 0.1, 0.4, 0.2, 0.05)
+    random_state = st.number_input("Random seed", value=42, step=1)
+
+st.markdown("### 🔍 Visão geral dos dados")
+st.write(f"Linhas: **{df_raw.shape[0]}**, Colunas: **{df_raw.shape[1]}**")
+st.dataframe(df_raw[[c for c in [target_col] + selected_feats if c in df_raw.columns]].head(10))
+
+# -----------------------------
+# Preparação
+# -----------------------------
+df = df_raw.dropna(subset=[target_col]).copy()
+y = df[target_col].astype(int)
+X = df[selected_feats].copy()
+
+# Tipos
+sel_num = [c for c in selected_feats if c in X.columns and np.issubdtype(X[c].dtype, np.number)]
+sel_cat = [c for c in selected_feats if c in X.columns and (X[c].dtype == "object" or X[c].dtype.name == "category")]
+
+pre = build_preprocessor(sel_num, sel_cat)
+model = get_model(model_name)
+
+pipe = Pipeline([
+    ("pre", pre),
+    ("clf", model)
+])
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=test_size, random_state=random_state, stratify=y
+)
+
+# -----------------------------
+# Treinamento
+# -----------------------------
+with st.spinner("Treinando modelo..."):
+    pipe.fit(X_train, y_train)
+
+# Predições e métricas
+proba_test = pipe.predict_proba(X_test)[:, 1]
+pred_test = (proba_test >= 0.5).astype(int)
+auc = roc_auc_score(y_test, proba_test)
+acc = accuracy_score(y_test, pred_test)
+cm = confusion_matrix(y_test, pred_test)
+
+met1, met2 = st.columns(2)
+with met1:
+    st.metric("AUC (ROC)", f"{auc:.3f}")
+with met2:
+    st.metric("Acurácia", f"{acc:.3f}")
+
+st.markdown("#### Matriz de confusão")
+cm_df = pd.DataFrame(cm, index=["Real 0", "Real 1"], columns=["Pred 0", "Pred 1"])
+st.dataframe(cm_df)
+
+# Curva ROC (usando altair simples)
+roc_points = []
+fpr_list = np.linspace(0, 1, 101)
+# Calcular TPR para limiares aproximados
+from sklearn.metrics import roc_curve
+fpr, tpr, thr = roc_curve(y_test, proba_test)
+roc_data = pd.DataFrame({"fpr": fpr, "tpr": tpr})
+roc_chart = alt.Chart(roc_data).mark_line().encode(x="fpr:Q", y="tpr:Q").properties(
+    height=250, width=380
+)
+diag = alt.Chart(pd.DataFrame({"x":[0,1],"y":[0,1]})).mark_line(strokeDash=[4,4]).encode(x="x", y="y")
+st.altair_chart(roc_chart + diag, use_container_width=True)
+
+# -----------------------------
+# Importância das variáveis
+# -----------------------------
+st.markdown("### 🌟 Importância das variáveis")
+with st.spinner("Calculando importância (permutation importance)..."):
+    perm = permutation_importance(pipe, X_test, y_test, n_repeats=10, random_state=42, scoring="roc_auc")
+    # Nomear features após o preprocessamento:
+    # Recupera nomes one-hot para categoricas
+    ohe = pipe.named_steps["pre"].named_transformers_.get("cat")
+    ohe_feat_names = []
+    if ohe is not None and hasattr(ohe, "named_steps"):
+        onehot = ohe.named_steps["onehot"]
+        if hasattr(onehot, "get_feature_names_out"):
+            ohe_feat_names = list(onehot.get_feature_names_out(sel_cat))
+    # Nomes finais
+    feat_names = sel_num + ohe_feat_names
+    imp_df = pd.DataFrame({
+        "feature": feat_names,
+        "importance": perm.importances_mean[:len(feat_names)]
+    }).sort_values("importance", ascending=False)
+
+# Para regressão logística, calcular sinal aproximado por coeficientes
+sign_map = {}
+if model_name == "Regressão Logística":
+    # Reconstruir coeficientes no espaço expandido:
+    # Ajusta novamente em X_train pretransformado para extrair coef
+    X_train_proc = pipe.named_steps["pre"].fit_transform(X_train)
+    clf = LogisticRegression(max_iter=200)
+    clf.fit(X_train_proc, y_train)
+    coefs = clf.coef_.ravel()
+    # Alinha tamanho; pode haver diferença por features descartadas
+    k = min(len(coefs), len(feat_names))
+    for i in range(k):
+        sign_map[feat_names[i]] = np.sign(coefs[i])
+
+imp_df["sign"] = imp_df["feature"].map(lambda f: sign_map.get(f, 0))
+st.dataframe(imp_df.head(15))
+
+# Chart
+bar = alt.Chart(imp_df.head(20)).mark_bar().encode(
+    x=alt.X("importance:Q", title="Perm. importance (AUC)"),
+    y=alt.Y("feature:N", sort='-x', title="Feature"),
+    color=alt.value("#3165d4")
+).properties(height=450)
+st.altair_chart(bar, use_container_width=True)
+
+# -----------------------------
+# Predição interativa
+# -----------------------------
+st.markdown("## 🔮 Predição interativa (probabilidade de reclamação)")
+st.caption("Ajuste os valores no painel e veja a probabilidade prevista pelo modelo.")
+
+# Constrói um dicionário de entradas
+with st.form("pred_form"):
+    cols = st.columns(3)
+    inputs = {}
+    for idx, col in enumerate(selected_feats):
+        col_container = cols[idx % 3]
+        with col_container:
+            if col in sel_num:
+                # Usa faixa baseada nos quantis do treino
+                q1, q5, q95, q99 = X_train[col].quantile([0.01, 0.05, 0.95, 0.99])
+                val = st.number_input(
+                    f"{col}",
+                    value=float(np.nan_to_num(X_train[col].median(), nan=0.0)),
+                    help=f"Faixa típica ~ {q5:.2f}–{q95:.2f} (1–99%: {q1:.2f}–{q99:.2f})"
+                )
+                inputs[col] = val
+            else:
+                opts = sorted([str(x) for x in X_train[col].dropna().unique().tolist()])[:30]
+                default = opts[0] if opts else ""
+                val = st.selectbox(f"{col}", options=opts if opts else [""], index=0 if opts else 0)
+                inputs[col] = val
+    submitted = st.form_submit_button("Calcular probabilidade")
+
+if submitted:
+    x_new = pd.DataFrame([inputs])
+    prob = pipe.predict_proba(x_new)[0, 1]
+    st.success(f"Probabilidade de registrar reclamação (Complain=1): **{prob:.2%}**")
+
+# -----------------------------
+# Inferência estatística (Logística)
+# -----------------------------
+st.markdown("## 📚 Inferência estatística (para mitigação)")
+st.caption("Quando o modelo selecionado é Regressão Logística, mostramos *odds ratios* com IC 95% (explicabilidade estatística).")
+
+if model_name == "Regressão Logística":
+    try:
+        # Reconstruir design matrix com OHE + padronização (para statsmodels, manter padronização ajuda numérica)
+        pre_fit = pipe.named_steps["pre"].fit(X_train, y_train)
+        X_train_proc = pre_fit.transform(X_train)
+        feature_names = sel_num + (
+            list(pre_fit.named_transformers_["cat"].named_steps["onehot"].get_feature_names_out(sel_cat))
+            if sel_cat else []
+        )
+        X_sm = sm.add_constant(pd.DataFrame(X_train_proc, columns=feature_names))
+        y_sm = y_train.values
+        logit = sm.Logit(y_sm, X_sm).fit(disp=False)
+        or_table = coefficient_table_for_logit(logit, feature_names)
+        st.dataframe(or_table[["feature", "odds_ratio", "or_ci_low", "or_ci_high"]].round(3))
+
+        st.info(
+            "Interpretação: valores de *odds ratio* > 1 aumentam a chance de reclamação; "
+            "< 1 reduzem. Use os IC para priorizar intervenções mais robustas."
+        )
+    except Exception as e:
+        st.warning(f"Não foi possível calcular os intervalos de confiança: {e}")
+
+# -----------------------------
+# Item (c): Definição & Seleção de Modelos
+# -----------------------------
+st.markdown("## 🧠 Item (c) — Definição & Seleção de Modelos")
+st.write("""
+**Regressão Logística** foi escolhida por sua interpretabilidade (odds ratios) e por modelar diretamente a probabilidade de `Complain=1`.
+Em paralelo, **Random Forest** foi incluída como baseline não linear robusto a interações e efeitos não lineares. A escolha final pode ser
+guiada por **AUC/ROC**, **acurácia** e capacidade de **explicação** necessária ao negócio. Para variáveis mistas (numéricas/categóricas),
+aplicamos *imputação*, *padronização* (numéricas) e *one-hot* (categóricas) para garantir comparabilidade e estabilidade do treinamento.
+""")
+
+# -----------------------------
+# Item (e): Recomendações estratégicas
+# -----------------------------
+st.markdown("## 🧭 Item (e) — Recomendações para a Tomada de Decisão")
+recs = make_recommendations(imp_df, top_k=5)
+for r in recs:
+    st.markdown("- " + r)
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+st.markdown("---")
+st.caption("PPCA/UnB • Tarefa 6 — Modelos Supervisionados • App em Streamlit para Hugging Face Spaces")