update

.gitignore

@@ -0,0 +1,50 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Jupyter Notebook
+.ipynb_checkpoints/
+*.ipynb_checkpoints
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Cache
+.cache/
+*.cache
+

DESCRICAO.md

@@ -0,0 +1,131 @@
+Prova Final de Análise Estatística de Dados e Informações
+
+Novembro - 2025
+
+Questão 1 – (2,5 pontos)
+
+Esta questão aborda a aplicação prática de um problema de Ciência de Dados utilizando Regressão Linear. O objetivo é prever preços de imóveis com base em dados reais da região de King County, nos Estados Unidos. A base de dados utilizada é a Previsão de Vendas de Imóveis em King County (EUA). Siga os passos abaixo para desenvolver sua solução:
+
+Instruções:
+
+    Análise Descritiva dos Dados (20%)
+
+        Realize uma análise inicial da base de dados.
+
+        Inclua estatísticas descritivas (média, mediana, desvio padrão, etc.) e gráficos relevantes (distribuições, correlações, etc.).
+
+    Construção do Modelo de Regressão Linear (30%)
+
+        Construa um modelo de Regressão Linear para prever os preços dos imóveis.
+
+        Apresente os coeficientes do modelo, R2 e outras métricas de avaliação.
+
+    Interpretação dos Resultados (10%)
+
+        Explique os resultados obtidos pelo modelo, destacando o impacto de cada variável nas previsões e explicações do fenômeno.
+
+        Verifique se os pressupostos da Regressão Linear (linearidade, homocedasticidade, normalidade dos resíduos, etc.) foram atendidos.
+
+    Ajustes no Modelo (30%)
+
+        Identifique possíveis problemas nos pressupostos do modelo.
+
+        Apresente soluções para corrigir esses problemas, como transformações de variáveis ou ajustes no modelo.
+
+        Reavalie o desempenho do modelo ajustado.
+
+    Tomada de Decisão (10%)
+
+        Com base no modelo final, explique como os resultados podem ser aplicados em um contexto de negócios.
+
+        Forneça exemplos de decisões estratégicas que poderiam ser tomadas com base nas previsões.
+
+Questão 2 – (2,5 pontos)
+
+Esta questão aborda a aplicação prática de um problema de Ciência de Dados utilizando Machine Learning. O objetivo é prever se os indivíduos irão cancelar suas reservas em uma rede de hotéis, utilizando o conjunto de dados Hotel Booking Demand. Siga os passos abaixo para desenvolver sua solução:
+
+Instruções:
+
+a) Análise Descritiva dos Dados (10%)
+
+    Realize uma análise descritiva da base de dados.
+
+    Inclua gráficos e tabelas para explorar as características dos dados. b) Modelo de Regressão Logística (60%)
+
+    Construa um modelo de Regressão Logística para prever o cancelamento das reservas.
+
+    Apresente as métricas de desempenho do modelo, como acurácia, precisão, recall e F1-score. c) Análise das Features (20%)
+
+    Identifique as features mais importantes para o cancelamento das reservas.
+
+    Interprete os resultados, destacando quais variáveis têm maior impacto na previsão. d) Justificativa do Método (10%)
+
+    Explique por que a Regressão Logística é mais apropriada para este problema em comparação à Regressão Linear.
+
+Questão 3 – (2,0 pontos)
+
+Esta questão aborda a aplicação prática de um problema de ANOVA (Análise de Variância) utilizando dados reais empregados em contextos empresariais. O objetivo é analisar as médias de quantidades e preços de produtos agrupados por países, utilizando o conjunto de dados Vendas de Varejo Online. Siga os passos abaixo para desenvolver sua solução:
+
+Instruções:
+
+a) Análise Descritiva dos Dados (10%)
+
+    Realize uma análise inicial da base de dados.
+
+    Inclua gráficos e tabelas que explorem as variáveis de interesse. b) Comparação entre Países (ANOVA) (40%)
+
+    Realize uma análise de variância (ANOVA) para comparar as médias de quantidade e preço dos produtos, agrupados por países.
+
+    Apresente os resultados estatísticos, incluindo valores de F, p-valor e a interpretação dos mesmos. c) Ajustes no Modelo de ANOVA (40%)
+
+    Verifique os pressupostos da ANOVA (normalidade, homocedasticidade, etc.).
+
+    Corrija possíveis problemas identificados e apresente um modelo ajustado. d) Interpretação e Tomada de Decisão (10%)
+
+    Interprete os resultados finais da análise.
+
+    Destaque possíveis decisões estratégicas baseadas nos resultados encontrados.
+
+Questão 4 – (3,0 pontos)
+
+Você é analista de dados de uma instituição financeira. Sua missão é desenvolver um modelo preditivo para identificar clientes com maior probabilidade de se tornarem maus pagadores (inadimplentes). O banco quer usar essas informações para reduzir riscos, melhorar sua carteira de crédito e apoiar decisões estratégicas de concessão de empréstimos.
+
+Será utilizada a base de dados Risco de Crédito (Kaggle), que contém informações sociodemográficas, comportamentais e financeiras dos clientes.
+
+Variável-alvo: Class – good se o cliente é considerado bom pagador; bad se for mau pagador.
+
+Instruções:
+
+a) Discussão sobre o problema (10%)
+
+    Contextualize o problema de risco de crédito no setor bancário e sua importância para a economia.
+
+    Explique por que prever inadimplência é essencial para reduzir perdas e melhorar a gestão de crédito. b) Análise Descritiva dos Dados (15%)
+
+    Realize uma análise exploratória da base de dados.
+
+    Apresente estatísticas descritivas e gráficos para compreender o comportamento das variáveis e sua relação com a variável Class.
+
+    Faça tratamento de valores ausentes, padronização e codificação de variáveis, se necessário. c) Definição e Seleção dos Modelos (30%)
+
+    Escolha modelos de previsão adequados para o problema (ex: Regressão Logística, Árvore de Decisão, Random Forest, XGBoost, SVM).
+
+    Justifique sua escolha com base nas características dos dados e no objetivo da análise.
+
+    Compare os modelos utilizando métricas como acurácia, precisão, recall, F1-score e AUC. d) Explicabilidade das Variáveis – SHAP value (25%)
+
+    Utilize SHAP values no modelo final para identificar as variáveis mais relevantes para a previsão de inadimplência.
+
+    Apresente gráficos interpretativos (ex: summary plot, force plot) e discuta o significado das variáveis mais influentes no contexto bancário e econômico. e) Análise Não Supervisionada com K-Means e DBSCAN (15%)
+
+    Aplique K-Means para segmentar os clientes com base em características como renda, idade, histórico de crédito, tempo de emprego etc.
+
+    Justifique o número de clusters e interprete os perfis obtidos.
+
+    Aplique DBSCAN para detectar perfis atípicos (outliers) que possam indicar risco elevado de inadimplência.
+
+    Compare os resultados e discuta como os agrupamentos podem complementar a análise supervisionada. f) Tomada de Decisão Estratégica (10%)
+
+    Com base nos resultados obtidos, sugira ações que o banco poderia adotar para reduzir riscos futuros (ex: políticas de concessão, segmentação de clientes, ações de prevenção).
+
+    Aponte como a análise de dados pode orientar estratégias de retenção, concessão responsável de crédito e prevenção de inadimplência.

Dockerfile

@@ -31,7 +31,10 @@ RUN apt-get purge -y build-essential gcc g++ \
 RUN groupadd -r appuser && useradd -r -g appuser appuser
 
 COPY src/ ./src/
-COPY marketing_campaign.csv ./
+COPY questao-1/ ./questao-1/
+COPY questao-2/ ./questao-2/
+COPY questao-3/ ./questao-3/
+COPY questao-4/ ./questao-4/
 COPY .streamlit/ ./.streamlit/
 
 # Set proper permissions

README.md

@@ -1,14 +1,126 @@
----
-title: "Análise de Personalidade Consumidor"
-emoji: "🏦"
-colorFrom: "blue"
-colorTo: "red"
-sdk: "docker"
-app_file: "Dockerfile"
-app_port: 8501
-tags:
- - streamlit
-pinned: false
-short_description: "Personalidade Consumidor"
-license: mit
----
+# Prova Final de Análise Estatística de Dados e Informações
+
+**Novembro - 2025**
+
+- **Autor:** Hugo Honda
+- **Disciplina:** AEDI - PPCA/UnB
+
+## Estrutura do Projeto
+
+O projeto está organizado por questões, cada uma em sua própria pasta:
+
+```
+prova-final/
+├── questao-1/          # Regressão Linear - Preços de Imóveis
+│   ├── questao-1.ipynb
+│   ├── kc_house_data.csv
+│   └── src/
+│       └── streamlit_app.py
+├── questao-2/          # Regressão Logística - Cancelamento de Reservas
+│   ├── questao-2.ipynb
+│   ├── hotel_bookings.csv
+│   └── src/
+│       └── streamlit_app.py
+├── questao-3/          # ANOVA - Vendas de Varejo Online
+│   ├── questao-3.ipynb
+│   ├── online_retail_II.xlsx
+│   ├── Year 2009-2010.csv
+│   ├── Year 2010-2011.csv
+│   └── src/
+│       └── streamlit_app.py
+├── questao-4/          # Risco de Crédito - ML e Clustering
+│   ├── questao-4.ipynb
+│   ├── credit_customers.csv
+│   └── src/
+│       └── streamlit_app.py
+├── src/
+│   └── streamlit_app.py    # App principal que integra todas as questões
+├── requirements.txt
+├── Dockerfile
+└── README.md
+```
+
+## Questões
+
+### Questão 1 - Regressão Linear (2,5 pontos)
+- **Dataset:** King County House Sales (`kc_house_data.csv`)
+- **Objetivo:** Prever preços de imóveis
+- **Técnica:** Regressão Linear
+
+### Questão 2 - Regressão Logística (2,5 pontos)
+- **Dataset:** Hotel Booking Demand (`hotel_bookings.csv`)
+- **Objetivo:** Prever cancelamento de reservas
+- **Técnica:** Regressão Logística
+
+### Questão 3 - ANOVA (2,0 pontos)
+- **Dataset:** Online Retail (`online_retail_II.xlsx` ou CSVs)
+- **Objetivo:** Comparar médias de quantidade e preço por país
+- **Técnica:** ANOVA
+
+### Questão 4 - Risco de Crédito (3,0 pontos)
+- **Dataset:** Credit Risk (`credit_customers.csv`)
+- **Objetivo:** Prever inadimplência
+- **Técnicas:** ML (Logistic Regression, Random Forest, XGBoost), SHAP, K-Means, DBSCAN
+
+## Como Executar
+
+### Localmente
+
+#### App Principal (todas as questões)
+```bash
+pip install -r requirements.txt
+streamlit run src/streamlit_app.py
+```
+
+#### App Individual por Questão
+```bash
+# Questão 1
+cd questao-1
+streamlit run src/streamlit_app.py
+
+# Questão 2
+cd questao-2
+streamlit run src/streamlit_app.py
+
+# Questão 3
+cd questao-3
+streamlit run src/streamlit_app.py
+
+# Questão 4
+cd questao-4
+streamlit run src/streamlit_app.py
+```
+
+### Docker
+
+```bash
+docker build -t prova-final .
+docker run -p 8501:8501 prova-final
+```
+
+### Hugging Face Spaces
+
+O projeto está configurado para ser deployado no Hugging Face Spaces usando Docker.
+
+## Notebooks
+
+Cada questão possui seu próprio notebook Jupyter:
+- `questao-1/questao-1.ipynb`
+- `questao-2/questao-2.ipynb`
+- `questao-3/questao-3.ipynb`
+- `questao-4/questao-4.ipynb`
+
+Os notebooks contêm a análise completa de cada questão e podem ser executados independentemente.
+
+## Dependências
+
+Ver `requirements.txt` para lista completa de dependências.
+
+Principais bibliotecas:
+- pandas, numpy
+- scikit-learn
+- streamlit, plotly
+- statsmodels, scipy
+- xgboost, shap
+- imbalanced-learn
+- openpyxl (para ler Excel)

questao-1/kc_house_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0875baa0251b21d4bdc9d2ae940a4fe0bb6009824f23dd0e2a5b2bf04557b7e
+size 2515206

questao-1/src/streamlit_app.py

@@ -0,0 +1,614 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import warnings
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import statsmodels.api as sm
+import streamlit as st
+from scipy import stats
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+from sklearn.model_selection import train_test_split
+from statsmodels.stats.diagnostic import het_breuschpagan
+from statsmodels.stats.stattools import durbin_watson
+
+warnings.filterwarnings("ignore")
+
+st.set_page_config(
+    page_title="Questão 1 - Regressão Linear",
+    page_icon="🏠",
+    layout="wide",
+)
+
+st.markdown("""
+# Questão 1 – Regressão Linear para Previsão de Preços de Imóveis
+
+**King County House Sales Dataset**
+
+- **Autor:** Hugo Honda
+- **Disciplina:** AEDI - PPCA/UnB
+- **Data:** Novembro 2025
+
+---
+
+## Objetivos da Análise
+
+1. **Análise Descritiva dos Dados**: Explorar características e distribuições
+2. **Construção do Modelo**: Desenvolver modelo de regressão linear robusto
+3. **Interpretação dos Resultados**: Avaliar performance e significância das variáveis
+4. **Ajustes no Modelo**: Validar pressupostos e otimizar predições
+5. **Tomada de Decisão**: Fornecer ferramenta de previsão interativa
+""")
+
+
+@st.cache_data
+def load_data():
+    """Carrega e prepara os dados do King County House Sales Dataset"""
+    try:
+        df = pd.read_csv("kc_house_data.csv")
+        df_clean = df.copy()
+
+        # Remover duplicatas
+        df_clean = df_clean.drop_duplicates(subset=["id"])
+
+        # Remover outliers extremos (1% e 99%)
+        Q1 = df_clean["price"].quantile(0.01)
+        Q99 = df_clean["price"].quantile(0.99)
+        df_clean = df_clean[(df_clean["price"] >= Q1) & (df_clean["price"] <= Q99)]
+
+        features = [
+            "bedrooms",
+            "bathrooms",
+            "sqft_living",
+            "sqft_lot",
+            "floors",
+            "waterfront",
+            "view",
+            "condition",
+            "grade",
+            "sqft_above",
+            "sqft_basement",
+            "yr_built",
+            "yr_renovated",
+            "lat",
+            "long",
+            "sqft_living15",
+            "sqft_lot15",
+        ]
+
+        return df_clean, features
+    except FileNotFoundError as e:
+        st.error(
+            f"Erro ao carregar dados: {str(e)}\n\nVerifique se o arquivo kc_house_data.csv está presente."
+        )
+        return None, None
+    except Exception as e:
+        st.error(f"Erro inesperado ao carregar dados: {str(e)}")
+        return None, None
+
+
+df_clean, features = load_data()
+
+if df_clean is not None:
+    # =============================
+    # Sidebar - Controles
+    # =============================
+
+    st.sidebar.header("🎛️ Controles da Análise")
+
+    st.sidebar.subheader("Parâmetros do Modelo")
+    test_size = st.sidebar.slider("Tamanho do conjunto de teste:", 0.1, 0.4, 0.2, 0.05)
+    random_state = st.sidebar.number_input("Random State:", 1, 1000, 42)
+    use_log_transform = st.sidebar.checkbox("Usar transformação logarítmica", True)
+
+    st.sidebar.subheader("Opções de Visualização")
+    show_eda = st.sidebar.checkbox("Mostrar análise exploratória", True)
+    show_assumptions = st.sidebar.checkbox("Mostrar validação de pressupostos", True)
+    show_predictions = st.sidebar.checkbox("Mostrar gráficos de predição", True)
+
+    # =============================
+    # Análise Exploratória
+    # =============================
+
+    if show_eda:
+        st.header("📊 Análise Exploratória dos Dados")
+
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Total de Observações", f"{len(df_clean):,}")
+        with col2:
+            st.metric("Preço Médio", f"${df_clean['price'].mean():,.0f}")
+        with col3:
+            st.metric("Preço Mínimo", f"${df_clean['price'].min():,.0f}")
+        with col4:
+            st.metric("Preço Máximo", f"${df_clean['price'].max():,.0f}")
+
+        # Distribuição de preços
+        fig_hist = px.histogram(
+            df_clean,
+            x="price",
+            nbins=50,
+            title="Distribuição de Preços dos Imóveis",
+            marginal="box",
+            labels={"price": "Preço ($)", "count": "Frequência"},
+        )
+        fig_hist.update_layout(showlegend=False, bargap=0.02)
+        st.plotly_chart(fig_hist, use_container_width=True)
+
+        # Correlações com o preço
+        corr_data = (
+            df_clean[features + ["price"]]
+            .corr()["price"]
+            .sort_values(ascending=False)[1:11]
+        )
+
+        fig_corr = px.bar(
+            x=corr_data.values,
+            y=corr_data.index,
+            orientation="h",
+            title="Top 10 Variáveis Mais Correlacionadas com o Preço",
+            labels={"x": "Correlação", "y": "Variável"},
+            color=corr_data.values,
+            color_continuous_scale="RdYlGn",
+        )
+        fig_corr.update_layout(showlegend=False)
+        st.plotly_chart(fig_corr, use_container_width=True)
+
+    # =============================
+    # Modelagem
+    # =============================
+
+    st.header("🔬 Modelagem de Regressão Linear")
+
+    X = df_clean[features].copy()
+    y = df_clean["price"].copy()
+
+    # Divisão treino-teste
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_size, random_state=random_state
+    )
+
+    # Transformação logarítmica se selecionada
+    y_train_model = np.log1p(y_train) if use_log_transform else y_train.copy()
+    y_test_model = np.log1p(y_test) if use_log_transform else y_test.copy()
+    transform_label = " (com transformação logarítmica)" if use_log_transform else ""
+
+    # Ajustar modelo
+    model = LinearRegression()
+    model.fit(X_train, y_train_model)
+
+    # Predições
+    y_pred_train = model.predict(X_train)
+    y_pred_test = model.predict(X_test)
+
+    # Reverter transformação se necessário
+    y_pred_train_price = np.expm1(y_pred_train) if use_log_transform else y_pred_train.copy()
+    y_pred_test_price = np.expm1(y_pred_test) if use_log_transform else y_pred_test.copy()
+
+    # =============================
+    # Resultados do Modelo
+    # =============================
+
+    st.subheader(f"📈 Resultados do Modelo{transform_label}")
+
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        r2_train = r2_score(y_train, y_pred_train_price)
+        r2_test = r2_score(y_test, y_pred_test_price)
+        st.metric("R² Treino", f"{r2_train:.4f}")
+        st.metric("R² Teste", f"{r2_test:.4f}")
+
+    with col2:
+        rmse_train = np.sqrt(mean_squared_error(y_train, y_pred_train_price))
+        rmse_test = np.sqrt(mean_squared_error(y_test, y_pred_test_price))
+        st.metric("RMSE Treino", f"${rmse_train:,.0f}")
+        st.metric("RMSE Teste", f"${rmse_test:,.0f}")
+
+    with col3:
+        mae_train = mean_absolute_error(y_train, y_pred_train_price)
+        mae_test = mean_absolute_error(y_test, y_pred_test_price)
+        st.metric("MAE Treino", f"${mae_train:,.0f}")
+        st.metric("MAE Teste", f"${mae_test:,.0f}")
+
+    st.info(f"""
+    **Interpretação das Métricas:**
+    - **R² = {r2_test:.4f}**: O modelo explica {r2_test * 100:.1f}% da variância nos preços
+    - **RMSE = ${rmse_test:,.0f}**: Erro médio de previsão de ${rmse_test:,.0f}
+    - **MAE = ${mae_test:,.0f}**: Erro absoluto médio de ${mae_test:,.0f}
+    - **Transformação**: {"Logarítmica aplicada para normalizar distribuição" if use_log_transform else "Valores originais sem transformação"}
+    """)
+
+    # Coeficientes
+    st.subheader("🎯 Importância das Variáveis")
+
+    coef_df = pd.DataFrame({"Variável": features, "Coeficiente": model.coef_})
+    coef_df["Abs_Coefficient"] = np.abs(coef_df["Coeficiente"])
+    coef_df = coef_df.sort_values("Abs_Coefficient", ascending=False)
+
+    top_vars = coef_df.head(15)
+
+    fig_coef = px.bar(
+        top_vars,
+        x="Coeficiente",
+        y="Variável",
+        orientation="h",
+        title="Coeficientes das 15 Variáveis Mais Importantes",
+        color="Abs_Coefficient",
+        color_continuous_scale="Viridis",
+    )
+    fig_coef.update_layout(height=500)
+    st.plotly_chart(fig_coef, use_container_width=True)
+
+    # Tabela de coeficientes
+    with st.expander("📋 Ver todos os coeficientes"):
+        st.dataframe(
+            coef_df[["Variável", "Coeficiente"]].reset_index(drop=True),
+            use_container_width=True,
+        )
+
+    # =============================
+    # Validação de Pressupostos
+    # =============================
+
+    if show_assumptions:
+        st.header("🔍 Validação dos Pressupostos da Regressão Linear")
+
+        # Calcular resíduos
+        residuals = y_train - y_pred_train_price
+
+        # Testes estatísticos
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.subheader("📊 Testes Estatísticos")
+
+            # Homocedasticidade (Breusch-Pagan)
+            X_train_sm = sm.add_constant(X_train)
+            bp_stat, bp_p, _, _ = het_breuschpagan(residuals, X_train_sm)
+            bp_ok = bp_p > 0.05
+            st.metric(
+                "Homocedasticidade (Breusch-Pagan)",
+                "✅ OK" if bp_ok else "❌ Violado",
+                f"p-value = {bp_p:.4f}",
+            )
+
+            # Independência (Durbin-Watson)
+            dw_stat = durbin_watson(residuals)
+            dw_ok = 1.5 < dw_stat < 2.5
+            st.metric(
+                "Independência (Durbin-Watson)",
+                "✅ OK" if dw_ok else "⚠️ Atenção",
+                f"DW = {dw_stat:.4f}",
+            )
+
+            # Normalidade (Shapiro-Wilk em amostra)
+            if len(residuals) <= 5000:
+                sample_residuals = residuals
+            else:
+                sample_residuals = residuals.sample(5000, random_state=42)
+
+            shapiro_stat, shapiro_p = stats.shapiro(sample_residuals)
+            shapiro_ok = shapiro_p > 0.05
+            st.metric(
+                "Normalidade dos Resíduos (Shapiro-Wilk)",
+                "✅ OK" if shapiro_ok else "❌ Violado",
+                f"p-value = {shapiro_p:.4f}",
+            )
+
+        with col2:
+            st.subheader("📈 Distribuição dos Resíduos")
+
+            fig_resid_hist = px.histogram(
+                x=residuals,
+                nbins=50,
+                title="Histograma dos Resíduos",
+                labels={"x": "Resíduos", "y": "Frequência"},
+            )
+            fig_resid_hist.update_layout(showlegend=False, height=300)
+            st.plotly_chart(fig_resid_hist, use_container_width=True)
+
+        # Gráfico de resíduos vs valores ajustados
+        fig_resid = px.scatter(
+            x=y_pred_train_price,
+            y=residuals,
+            title="Resíduos vs Valores Preditos (Conjunto de Treino)",
+            labels={"x": "Valores Preditos ($)", "y": "Resíduos ($)"},
+            opacity=0.5,
+        )
+        fig_resid.add_hline(
+            y=0, line_dash="dash", line_color="red", annotation_text="y=0"
+        )
+        st.plotly_chart(fig_resid, use_container_width=True)
+
+        # Q-Q Plot
+        fig_qq = go.Figure()
+
+        (osm, osr), (slope, intercept, r) = stats.probplot(residuals, dist="norm")
+
+        fig_qq.add_trace(
+            go.Scatter(
+                x=osm,
+                y=osr,
+                mode="markers",
+                name="Resíduos",
+                marker=dict(color="blue", opacity=0.5),
+            )
+        )
+        fig_qq.add_trace(
+            go.Scatter(
+                x=osm,
+                y=slope * osm + intercept,
+                mode="lines",
+                name="Linha teórica",
+                line=dict(color="red", dash="dash"),
+            )
+        )
+        fig_qq.update_layout(
+            title="Q-Q Plot - Normalidade dos Resíduos",
+            xaxis_title="Quantis Teóricos",
+            yaxis_title="Quantis da Amostra",
+        )
+        st.plotly_chart(fig_qq, use_container_width=True)
+
+        # Resumo dos pressupostos
+        st.subheader("✅ Resumo da Validação")
+
+        assumptions_status = pd.DataFrame(
+            {
+                "Pressuposto": [
+                    "Homocedasticidade",
+                    "Independência dos Resíduos",
+                    "Normalidade dos Resíduos",
+                ],
+                "Status": [
+                    "✅ Atendido" if bp_ok else "❌ Violado",
+                    "✅ Atendido" if dw_ok else "⚠️ Atenção",
+                    "✅ Atendido" if shapiro_ok else "❌ Violado",
+                ],
+                "Teste": [
+                    f"Breusch-Pagan (p={bp_p:.4f})",
+                    f"Durbin-Watson (DW={dw_stat:.4f})",
+                    f"Shapiro-Wilk (p={shapiro_p:.4f})",
+                ],
+            }
+        )
+        st.dataframe(assumptions_status, use_container_width=True)
+
+        if use_log_transform and (not shapiro_ok or not bp_ok):
+            st.success(
+                "💡 A transformação logarítmica geralmente melhora a normalidade e homocedasticidade."
+            )
+        elif not use_log_transform and (not shapiro_ok or not bp_ok):
+            st.warning(
+                "⚠️ Considere ativar a transformação logarítmica para melhorar os pressupostos."
+            )
+
+    # =============================
+    # Gráficos de Predição
+    # =============================
+
+    if show_predictions:
+        st.header("🔮 Análise das Predições")
+
+        # Valores Reais vs Preditos
+        fig_pred = px.scatter(
+            x=y_test,
+            y=y_pred_test_price,
+            title="Valores Reais vs Preditos (Conjunto de Teste)",
+            labels={"x": "Valores Reais ($)", "y": "Valores Preditos ($)"},
+            opacity=0.5,
+        )
+
+        # Linha de referência (y = x)
+        min_val = min(y_test.min(), y_pred_test_price.min())
+        max_val = max(y_test.max(), y_pred_test_price.max())
+        fig_pred.add_trace(
+            go.Scatter(
+                x=[min_val, max_val],
+                y=[min_val, max_val],
+                mode="lines",
+                name="Predição Perfeita (y=x)",
+                line=dict(dash="dash", color="red"),
+            )
+        )
+        st.plotly_chart(fig_pred, use_container_width=True)
+
+        # Resíduos do teste
+        residuals_test = y_test - y_pred_test_price
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            fig_resid_test = px.scatter(
+                x=y_pred_test_price,
+                y=residuals_test,
+                title="Resíduos vs Valores Preditos (Teste)",
+                labels={"x": "Valores Preditos ($)", "y": "Resíduos ($)"},
+                opacity=0.5,
+            )
+            fig_resid_test.add_hline(y=0, line_dash="dash", line_color="red")
+            st.plotly_chart(fig_resid_test, use_container_width=True)
+
+        with col2:
+            fig_resid_hist_test = px.histogram(
+                x=residuals_test,
+                nbins=50,
+                title="Distribuição dos Resíduos (Teste)",
+                labels={"x": "Resíduos ($)", "y": "Frequência"},
+            )
+            fig_resid_hist_test.update_layout(showlegend=False)
+            st.plotly_chart(fig_resid_hist_test, use_container_width=True)
+
+    # =============================
+    # Ferramenta de Previsão
+    # =============================
+
+    st.header("🏠 Ferramenta de Previsão de Preço")
+
+    st.markdown("""
+    Use os controles abaixo para inserir as características de um imóvel e obter uma previsão de preço.
+    """)
+
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        bedrooms = st.number_input("Quartos", min_value=0, max_value=10, value=3)
+        bathrooms = st.number_input(
+            "Banheiros", min_value=0.0, max_value=10.0, value=2.5, step=0.5
+        )
+        sqft_living = st.number_input(
+            "Área de Vivência (sqft)", min_value=0, value=2000
+        )
+        sqft_lot = st.number_input("Área do Lote (sqft)", min_value=0, value=8000)
+        floors = st.number_input(
+            "Andares", min_value=0.0, max_value=5.0, value=2.0, step=0.5
+        )
+        waterfront = st.selectbox(
+            "Beira-mar", [0, 1], format_func=lambda x: "Sim" if x == 1 else "Não"
+        )
+
+    with col2:
+        view = st.number_input("Vista (0-4)", min_value=0, max_value=4, value=2)
+        condition = st.number_input("Condição (1-5)", min_value=1, max_value=5, value=3)
+        grade = st.number_input("Grau (1-13)", min_value=1, max_value=13, value=7)
+        sqft_above = st.number_input(
+            "Área Acima do Solo (sqft)", min_value=0, value=1800
+        )
+        sqft_basement = st.number_input("Área do Porão (sqft)", min_value=0, value=200)
+
+    with col3:
+        yr_built = st.number_input(
+            "Ano de Construção", min_value=1900, max_value=2025, value=2000
+        )
+        yr_renovated = st.number_input(
+            "Ano de Renovação", min_value=0, max_value=2025, value=2010
+        )
+        lat = st.number_input(
+            "Latitude", min_value=47.0, max_value=48.0, value=47.5, step=0.01
+        )
+        long = st.number_input(
+            "Longitude", min_value=-123.0, max_value=-121.0, value=-122.3, step=0.01
+        )
+        sqft_living15 = st.number_input(
+            "Área Vivência Vizinhos (sqft)", min_value=0, value=1900
+        )
+        sqft_lot15 = st.number_input(
+            "Área Lote Vizinhos (sqft)", min_value=0, value=7500
+        )
+
+    if st.button("🔮 Prever Preço", type="primary"):
+        novo_imovel = pd.DataFrame(
+            {
+                "bedrooms": [bedrooms],
+                "bathrooms": [bathrooms],
+                "sqft_living": [sqft_living],
+                "sqft_lot": [sqft_lot],
+                "floors": [floors],
+                "waterfront": [waterfront],
+                "view": [view],
+                "condition": [condition],
+                "grade": [grade],
+                "sqft_above": [sqft_above],
+                "sqft_basement": [sqft_basement],
+                "yr_built": [yr_built],
+                "yr_renovated": [yr_renovated],
+                "lat": [lat],
+                "long": [long],
+                "sqft_living15": [sqft_living15],
+                "sqft_lot15": [sqft_lot15],
+            }
+        )
+
+        previsao = model.predict(novo_imovel[features])
+        previsao_price = np.expm1(previsao[0]) if use_log_transform else previsao[0]
+
+        # Calcular intervalo de confiança aproximado
+        margin = rmse_test * 1.96  # 95% de confiança
+
+        st.success(f"### 🎯 Previsão de Preço: ${previsao_price:,.2f}")
+
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Preço Estimado", f"${previsao_price:,.2f}")
+        with col2:
+            st.metric(
+                "Limite Inferior (95%)", f"${max(0, previsao_price - margin):,.2f}"
+            )
+        with col3:
+            st.metric("Limite Superior (95%)", f"${previsao_price + margin:,.2f}")
+
+        st.info(f"""
+        **Interpretação:**
+        - O preço estimado é de **${previsao_price:,.2f}**
+        - Com 95% de confiança, o preço real está entre **${max(0, previsao_price - margin):,.2f}** e **${previsao_price + margin:,.2f}**
+        - O erro médio do modelo (RMSE) é de **${rmse_test:,.0f}**
+        """)
+
+    # =============================
+    # Resumo Final
+    # =============================
+
+    st.header("📋 Resumo da Análise")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("🎯 Performance do Modelo")
+        performance_df = pd.DataFrame(
+            {
+                "Métrica": ["R² Score", "RMSE", "MAE"],
+                "Treino": [
+                    f"{r2_train:.4f}",
+                    f"${rmse_train:,.0f}",
+                    f"${mae_train:,.0f}",
+                ],
+                "Teste": [f"{r2_test:.4f}", f"${rmse_test:,.0f}", f"${mae_test:,.0f}"],
+            }
+        )
+        st.dataframe(performance_df, use_container_width=True)
+
+    with col2:
+        st.subheader("✅ Status dos Pressupostos")
+        if show_assumptions:
+            st.dataframe(assumptions_status, use_container_width=True)
+        else:
+            st.info(
+                "Ative 'Mostrar validação de pressupostos' para ver o status detalhado."
+            )
+
+    st.subheader("🔍 Principais Conclusões")
+
+    overfit = (r2_train - r2_test) > 0.1
+
+    conclusions = f"""
+    **Modelo de Regressão Linear para Preços de Imóveis:**
+
+    1. **Performance**: O modelo explica {r2_test * 100:.1f}% da variância nos preços (R² = {r2_test:.4f})
+    2. **Erro de Previsão**: RMSE de ${rmse_test:,.0f} e MAE de ${mae_test:,.0f}
+    3. **Generalização**: {"⚠️ Possível overfitting detectado" if overfit else "✅ Boa generalização entre treino e teste"}
+    4. **Transformação**: {"Transformação logarítmica aplicada melhorou a distribuição" if use_log_transform else "Modelo em escala original"}
+    5. **Variáveis Importantes**: {", ".join(top_vars.head(3)["Variável"].tolist())}
+    """
+
+    if show_assumptions:
+        all_ok = bp_ok and dw_ok and shapiro_ok
+        conclusions += f"\n6. **Pressupostos**: {'✅ Todos os pressupostos foram atendidos' if all_ok else '⚠️ Alguns pressupostos foram violados'}"
+
+    st.info(conclusions)
+
+else:
+    st.error(
+        "❌ Erro ao carregar os dados. Verifique se o arquivo kc_house_data.csv está presente no diretório."
+    )
+
+# =============================
+# Footer
+# =============================
+
+st.markdown("---")
+st.caption("PPCA/UnB | Novembro 2025")

questao-2/hotel_bookings.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c2ae42a7353905ea136e5c2287f17c92c5435826598bfbb8491c6f0c7b1fc06
+size 16855599

questao-2/src/streamlit_app.py

@@ -0,0 +1,627 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import warnings
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import streamlit as st
+from imblearn.over_sampling import SMOTE
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    f1_score,
+    precision_score,
+    recall_score,
+    roc_auc_score,
+    roc_curve,
+)
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+
+warnings.filterwarnings("ignore")
+
+st.set_page_config(
+    page_title="Questão 2 - Regressão Logística",
+    page_icon="🏨",
+    layout="wide",
+)
+
+st.markdown("""
+# Questão 2 – Regressão Logística para Previsão de Cancelamento de Reservas
+
+**Hotel Booking Demand Dataset**
+
+- **Autor:** Hugo Honda
+- **Disciplina:** AEDI - PPCA/UnB
+- **Data:** Novembro 2025
+
+---
+
+## Objetivos da Análise
+
+1. **Análise Descritiva dos Dados**: Explorar padrões de cancelamento
+2. **Modelo de Regressão Logística**: Construir modelo preditivo robusto
+3. **Análise das Features**: Identificar principais fatores de cancelamento
+4. **Justificativa do Método**: Avaliar adequação da regressão logística
+""")
+
+
+@st.cache_data
+def load_data():
+    """Carrega e prepara os dados do Hotel Booking Demand Dataset"""
+    try:
+        df = pd.read_csv("hotel_bookings.csv")
+
+        # Tratar valores ausentes
+        numeric_cols = df.select_dtypes(include=[np.number]).columns
+        for col in numeric_cols:
+            if df[col].isnull().sum() > 0:
+                df[col].fillna(df[col].median(), inplace=True)
+
+        categorical_cols = df.select_dtypes(include=["object"]).columns
+        for col in categorical_cols:
+            if df[col].isnull().sum() > 0:
+                df[col].fillna(df[col].mode()[0], inplace=True)
+
+        # Features do dataset
+        numeric_features = [
+            "lead_time",
+            "arrival_date_week_number",
+            "arrival_date_day_of_month",
+            "stays_in_weekend_nights",
+            "stays_in_week_nights",
+            "adults",
+            "children",
+            "babies",
+            "previous_cancellations",
+            "previous_bookings_not_canceled",
+            "booking_changes",
+            "days_in_waiting_list",
+            "adr",
+            "required_car_parking_spaces",
+            "total_of_special_requests",
+        ]
+
+        categorical_features = [
+            "hotel",
+            "arrival_date_month",
+            "meal",
+            "country",
+            "market_segment",
+            "distribution_channel",
+            "reserved_room_type",
+            "assigned_room_type",
+            "deposit_type",
+            "customer_type",
+        ]
+
+        return df, numeric_features, categorical_features
+    except FileNotFoundError as e:
+        st.error(
+            f"Erro ao carregar dados: {str(e)}\n\nVerifique se o arquivo hotel_bookings.csv está presente."
+        )
+        return None, None, None
+    except Exception as e:
+        st.error(f"Erro inesperado ao carregar dados: {str(e)}")
+        return None, None, None
+
+
+df, numeric_features, categorical_features = load_data()
+target_col = "is_canceled"
+
+if df is not None:
+    # =============================
+    # Sidebar - Controles
+    # =============================
+
+    st.sidebar.header("🎛️ Controles da Análise")
+
+    st.sidebar.subheader("Parâmetros do Modelo")
+    test_size = st.sidebar.slider("Tamanho do conjunto de teste:", 0.1, 0.4, 0.2, 0.05)
+    random_state = st.sidebar.number_input("Random State:", 1, 1000, 42)
+    use_smote = st.sidebar.checkbox("Usar SMOTE para balanceamento", True)
+    max_iter = st.sidebar.number_input("Máximo de iterações:", 100, 2000, 1000, 100)
+
+    st.sidebar.subheader("Opções de Visualização")
+    show_eda = st.sidebar.checkbox("Mostrar análise exploratória", True)
+    show_confusion = st.sidebar.checkbox("Mostrar matriz de confusão", True)
+    show_roc = st.sidebar.checkbox("Mostrar curva ROC", True)
+    show_feature_importance = st.sidebar.checkbox(
+        "Mostrar importância das features", True
+    )
+
+    # =============================
+    # Análise Exploratória
+    # =============================
+
+    if show_eda:
+        st.header("📊 Análise Descritiva dos Dados")
+
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Total de Observações", f"{len(df):,}")
+        with col2:
+            cancel_rate = df[target_col].mean()
+            st.metric("Taxa de Cancelamento", f"{cancel_rate:.2%}")
+        with col3:
+            st.metric("Features Numéricas", len(numeric_features))
+        with col4:
+            st.metric("Features Categóricas", len(categorical_features))
+
+        # Distribuição da variável target
+        target_counts = df[target_col].value_counts()
+
+            fig_target = go.Figure(
+                data=[
+                    go.Pie(
+                        labels=["Não Cancelado", "Cancelado"],
+                        values=target_counts.values,
+                        hole=0.4,
+                        marker_colors=["#00CC96", "#EF553B"],
+                    )
+                ]
+            )
+            fig_target.update_layout(title="Distribuição de Cancelamentos")
+            st.plotly_chart(fig_target, use_container_width=True)
+
+        # Análise de cancelamento por características
+        col1, col2 = st.columns(2)
+
+        with col1:
+            cancel_by_hotel = (
+                df.groupby("hotel")[target_col].mean().sort_values(ascending=False)
+            )
+            fig_hotel = px.bar(
+                x=cancel_by_hotel.index,
+                y=cancel_by_hotel.values,
+                title="Taxa de Cancelamento por Tipo de Hotel",
+                labels={"x": "Tipo de Hotel", "y": "Taxa de Cancelamento"},
+                color=cancel_by_hotel.values,
+                color_continuous_scale="RdYlGn_r",
+            )
+            st.plotly_chart(fig_hotel, use_container_width=True)
+
+        with col2:
+            cancel_by_deposit = (
+                df.groupby("deposit_type")[target_col]
+                .mean()
+                .sort_values(ascending=False)
+            )
+            fig_deposit = px.bar(
+                x=cancel_by_deposit.index,
+                y=cancel_by_deposit.values,
+                title="Taxa de Cancelamento por Tipo de Depósito",
+                labels={"x": "Tipo de Depósito", "y": "Taxa de Cancelamento"},
+                color=cancel_by_deposit.values,
+                color_continuous_scale="RdYlGn_r",
+            )
+            st.plotly_chart(fig_deposit, use_container_width=True)
+
+        # Distribuição de lead_time
+        fig_lead = px.box(
+                df,
+                x=target_col,
+                y="lead_time",
+                title="Distribuição de Lead Time por Status de Cancelamento",
+                labels={target_col: "Cancelado", "lead_time": "Lead Time (dias)"},
+                color=target_col,
+                color_discrete_map={0: "#00CC96", 1: "#EF553B"},
+            )
+        st.plotly_chart(fig_lead, use_container_width=True)
+
+    # =============================
+    # Modelagem
+    # =============================
+
+    st.header("🔬 Modelo de Regressão Logística")
+
+    # Preparar dados
+    df_model = df.copy()
+    le_dict = {}
+
+    for col in categorical_features:
+        le = LabelEncoder()
+        df_model[col] = le.fit_transform(df_model[col].astype(str))
+        le_dict[col] = le
+
+    all_features = numeric_features + categorical_features
+    X = df_model[all_features].copy()
+    y = df_model[target_col].copy()
+
+    # Tratar valores infinitos
+    X = X.replace([np.inf, -np.inf], np.nan).fillna(X.median())
+
+    # Divisão treino-teste
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_size, random_state=random_state, stratify=y
+    )
+
+    # Normalização
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+
+    # Balanceamento com SMOTE
+    if use_smote:
+        smote = SMOTE(random_state=random_state)
+        X_train_balanced, y_train_balanced = smote.fit_resample(X_train_scaled, y_train)
+        st.info(f"✅ SMOTE aplicado: {len(X_train_scaled)} → {len(X_train_balanced)} amostras de treino")
+    else:
+        X_train_balanced, y_train_balanced = X_train_scaled, y_train
+
+    # Treinar modelo
+    model = LogisticRegression(
+        random_state=random_state,
+        max_iter=max_iter,
+        class_weight="balanced",
+        solver="lbfgs",
+    )
+    model.fit(X_train_balanced, y_train_balanced)
+
+    # Predições
+    y_pred_train = model.predict(X_train_scaled)
+    y_pred_test = model.predict(X_test_scaled)
+    y_pred_proba_train = model.predict_proba(X_train_scaled)[:, 1]
+    y_pred_proba_test = model.predict_proba(X_test_scaled)[:, 1]
+
+    # =============================
+    # Métricas de Desempenho
+    # =============================
+
+    st.subheader("📈 Métricas de Desempenho")
+
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        accuracy_train = accuracy_score(y_train, y_pred_train)
+        accuracy_test = accuracy_score(y_test, y_pred_test)
+        st.metric("Acurácia Treino", f"{accuracy_train:.4f}")
+        st.metric("Acurácia Teste", f"{accuracy_test:.4f}")
+
+    with col2:
+        precision_train = precision_score(y_train, y_pred_train, zero_division=0)
+        precision_test = precision_score(y_test, y_pred_test, zero_division=0)
+        st.metric("Precisão Treino", f"{precision_train:.4f}")
+        st.metric("Precisão Teste", f"{precision_test:.4f}")
+
+    with col3:
+        recall_train = recall_score(y_train, y_pred_train, zero_division=0)
+        recall_test = recall_score(y_test, y_pred_test, zero_division=0)
+        st.metric("Recall Treino", f"{recall_train:.4f}")
+        st.metric("Recall Teste", f"{recall_test:.4f}")
+
+    with col4:
+        f1_train = f1_score(y_train, y_pred_train, zero_division=0)
+        f1_test = f1_score(y_test, y_pred_test, zero_division=0)
+        roc_auc_train = roc_auc_score(y_train, y_pred_proba_train)
+        roc_auc_test = roc_auc_score(y_test, y_pred_proba_test)
+        st.metric("F1-Score Treino", f"{f1_train:.4f}")
+        st.metric("F1-Score Teste", f"{f1_test:.4f}")
+        st.metric("AUC-ROC Teste", f"{roc_auc_test:.4f}")
+
+    st.info(f"""
+    **Interpretação das Métricas:**
+    - **Acurácia = {accuracy_test:.2%}**: Percentual de predições corretas
+    - **Precisão = {precision_test:.2%}**: {precision_test * 100:.1f}% dos cancelamentos previstos são reais
+    - **Recall = {recall_test:.2%}**: {recall_test * 100:.1f}% dos cancelamentos reais foram identificados
+    - **F1-Score = {f1_test:.4f}**: Média harmônica entre precisão e recall
+    - **AUC-ROC = {roc_auc_test:.4f}**: Capacidade do modelo de discriminar entre classes
+    """)
+
+    # =============================
+    # Matriz de Confusão
+    # =============================
+
+    if show_confusion:
+        st.subheader("📊 Matriz de Confusão")
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            cm_train = confusion_matrix(y_train, y_pred_train)
+            fig_cm_train = px.imshow(
+                cm_train,
+                labels=dict(x="Predito", y="Real", color="Quantidade"),
+                x=["Não Cancelado", "Cancelado"],
+                y=["Não Cancelado", "Cancelado"],
+                text_auto=True,
+                title="Matriz de Confusão - Treino",
+                color_continuous_scale="Blues",
+            )
+            st.plotly_chart(fig_cm_train, use_container_width=True)
+
+        with col2:
+            cm_test = confusion_matrix(y_test, y_pred_test)
+            fig_cm_test = px.imshow(
+                cm_test,
+                labels=dict(x="Predito", y="Real", color="Quantidade"),
+                x=["Não Cancelado", "Cancelado"],
+                y=["Não Cancelado", "Cancelado"],
+                text_auto=True,
+                title="Matriz de Confusão - Teste",
+                color_continuous_scale="Blues",
+            )
+            st.plotly_chart(fig_cm_test, use_container_width=True)
+
+        # Métricas da matriz de confusão
+        tn, fp, fn, tp = cm_test.ravel()
+
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Verdadeiros Positivos", tp)
+        with col2:
+            st.metric("Verdadeiros Negativos", tn)
+        with col3:
+            st.metric("Falsos Positivos", fp)
+        with col4:
+            st.metric("Falsos Negativos", fn)
+
+    # =============================
+    # Curva ROC
+    # =============================
+
+    if show_roc:
+        st.subheader("📈 Curva ROC")
+
+        fpr_train, tpr_train, _ = roc_curve(y_train, y_pred_proba_train)
+        fpr_test, tpr_test, _ = roc_curve(y_test, y_pred_proba_test)
+
+        fig_roc = go.Figure()
+
+        fig_roc.add_trace(
+            go.Scatter(
+                x=fpr_train,
+                y=tpr_train,
+                mode="lines",
+                name=f"Treino (AUC = {roc_auc_train:.4f})",
+                line=dict(color="blue", width=2),
+            )
+        )
+
+        fig_roc.add_trace(
+            go.Scatter(
+                x=fpr_test,
+                y=tpr_test,
+                mode="lines",
+                name=f"Teste (AUC = {roc_auc_test:.4f})",
+                line=dict(color="green", width=2),
+            )
+        )
+
+        fig_roc.add_trace(
+            go.Scatter(
+                x=[0, 1],
+                y=[0, 1],
+                mode="lines",
+                name="Aleatório",
+                line=dict(color="red", width=2, dash="dash"),
+            )
+        )
+
+        fig_roc.update_layout(
+            title="Curva ROC - Receiver Operating Characteristic",
+            xaxis_title="Taxa de Falsos Positivos (FPR)",
+            yaxis_title="Taxa de Verdadeiros Positivos (TPR)",
+            width=800,
+            height=600,
+        )
+
+        st.plotly_chart(fig_roc, use_container_width=True)
+
+        st.info(f"""
+        **Interpretação da Curva ROC:**
+        - **AUC = {roc_auc_test:.4f}**: Quanto mais próximo de 1.0, melhor o modelo
+        - AUC > 0.9: Excelente
+        - AUC > 0.8: Muito Bom
+        - AUC > 0.7: Bom
+        - AUC > 0.6: Razoável
+        - AUC ≈ 0.5: Modelo aleatório
+        """)
+
+    # =============================
+    # Análise de Features
+    # =============================
+
+    if show_feature_importance:
+        st.header("🎯 Análise das Features")
+
+        st.subheader("Importância das Features (Coeficientes)")
+
+        feature_importance = pd.DataFrame(
+            {
+                "Feature": all_features,
+                "Coefficient": model.coef_[0],
+                "Abs_Coefficient": np.abs(model.coef_[0]),
+            }
+        ).sort_values("Abs_Coefficient", ascending=False)
+
+        top_features = feature_importance.head(20)
+
+        fig_coef = px.bar(
+            top_features,
+            x="Coefficient",
+            y="Feature",
+            orientation="h",
+            title="Top 20 Features Mais Importantes",
+            labels={"Coefficient": "Coeficiente", "Feature": "Variável"},
+            color="Coefficient",
+            color_continuous_scale="RdBu_r",
+        )
+        fig_coef.update_layout(height=600)
+        st.plotly_chart(fig_coef, use_container_width=True)
+
+        st.info("""
+        **Interpretação dos Coeficientes:**
+        - **Coeficientes positivos**: Aumentam a probabilidade de cancelamento
+        - **Coeficientes negativos**: Diminuem a probabilidade de cancelamento
+        - **Magnitude**: Quanto maior o valor absoluto, maior o impacto na predição
+        """)
+
+        # Tabela com todas as features
+        with st.expander("📋 Ver todas as features e coeficientes"):
+            display_df = feature_importance[["Feature", "Coefficient"]].reset_index(
+                drop=True
+            )
+            st.dataframe(display_df, use_container_width=True)
+
+        # Top features positivas e negativas
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.subheader("🔴 Top 5 Features que Aumentam Cancelamento")
+            top_positive = feature_importance.nlargest(5, "Coefficient")[
+                ["Feature", "Coefficient"]
+            ]
+            st.dataframe(top_positive.reset_index(drop=True), use_container_width=True)
+
+        with col2:
+            st.subheader("🟢 Top 5 Features que Diminuem Cancelamento")
+            top_negative = feature_importance.nsmallest(5, "Coefficient")[
+                ["Feature", "Coefficient"]
+            ]
+            st.dataframe(top_negative.reset_index(drop=True), use_container_width=True)
+
+    # =============================
+    # Justificativa do Método
+    # =============================
+
+    st.header("📝 Justificativa do Método")
+
+    st.markdown("""
+    ### Por que Regressão Logística?
+
+    A **Regressão Logística** é adequada para este problema pelos seguintes motivos:
+
+    1. **Problema de Classificação Binária**:
+       - Variável target é binária (cancelado/não cancelado)
+       - Regressão logística é especificamente desenhada para este tipo de problema
+
+    2. **Interpretabilidade**:
+       - Coeficientes representam odds ratios
+       - Fácil identificar fatores de risco
+       - Importante para decisões de negócio
+
+    3. **Probabilidades Calibradas**:
+       - Fornece probabilidades diretas de cancelamento
+       - Útil para ranking de risco e tomada de decisão
+
+    4. **Performance**:
+       - Modelo simples e eficiente
+       - Baixo risco de overfitting
+       - Rápido para treinar e fazer predições
+
+    5. **Requisitos Regulatórios**:
+       - Modelos interpretáveis são preferidos em contextos de negócio
+       - Facilita explicação para stakeholders
+
+    ### Limitações e Considerações
+
+    - Assume relação linear entre log-odds e features
+    - Pode não capturar interações complexas (considerar árvores/ensembles)
+    - Requer balanceamento de classes (SMOTE aplicado)
+    """)
+
+    # =============================
+    # Relatório de Classificação
+    # =============================
+
+    st.subheader("📋 Relatório de Classificação Detalhado")
+
+    report = classification_report(y_test, y_pred_test, output_dict=True)
+    report_df = pd.DataFrame(report).transpose()
+
+    st.dataframe(report_df.style.format("{:.4f}"), use_container_width=True)
+
+    # =============================
+    # Resumo Final
+    # =============================
+
+    st.header("📋 Resumo da Análise")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("🎯 Performance do Modelo")
+        performance_df = pd.DataFrame(
+            {
+                "Métrica": ["Acurácia", "Precisão", "Recall", "F1-Score", "AUC-ROC"],
+                "Treino": [
+                    f"{accuracy_train:.4f}",
+                    f"{precision_train:.4f}",
+                    f"{recall_train:.4f}",
+                    f"{f1_train:.4f}",
+                    f"{roc_auc_train:.4f}",
+                ],
+                "Teste": [
+                    f"{accuracy_test:.4f}",
+                    f"{precision_test:.4f}",
+                    f"{recall_test:.4f}",
+                    f"{f1_test:.4f}",
+                    f"{roc_auc_test:.4f}",
+                ],
+            }
+        )
+        st.dataframe(performance_df, use_container_width=True)
+
+    with col2:
+        st.subheader("✅ Informações do Modelo")
+        model_info = pd.DataFrame(
+            {
+                "Característica": [
+                    "Total de Features",
+                    "Amostras de Treino",
+                    "Amostras de Teste",
+                    "Balanceamento",
+                    "Normalização",
+                ],
+                "Valor": [
+                    len(all_features),
+                    len(X_train),
+                    len(X_test),
+                    "SMOTE Aplicado" if use_smote else "Não Aplicado",
+                    "StandardScaler",
+                ],
+            }
+        )
+        st.dataframe(model_info, use_container_width=True)
+
+    st.subheader("🔍 Principais Conclusões")
+
+    overfit = (accuracy_train - accuracy_test) > 0.1
+    good_performance = roc_auc_test >= 0.7
+
+    conclusions = f"""
+    **Modelo de Regressão Logística para Cancelamento de Reservas:**
+
+    1. **Performance Geral**: {"✅ Bom" if good_performance else "⚠️ Requer melhorias"} (AUC-ROC = {roc_auc_test:.4f})
+    2. **Acurácia**: {accuracy_test:.2%} das predições corretas
+    3. **Precisão**: {precision_test:.2%} dos cancelamentos previstos são verdadeiros
+    4. **Recall**: {recall_test:.2%} dos cancelamentos reais foram identificados
+    5. **Generalização**: {"⚠️ Possível overfitting detectado" if overfit else "✅ Boa generalização entre treino e teste"}
+    6. **Features Principais**: {", ".join(top_features.head(3)["Feature"].tolist())}
+    7. **Balanceamento**: {"✅ SMOTE aplicado com sucesso" if use_smote else "Sem balanceamento"}
+
+    **Recomendações:**
+    - {"✅ Modelo pronto para produção" if good_performance and not overfit else "⚠️ Considerar ajustes adicionais"}
+    - Monitorar performance em dados novos
+    - Atualizar modelo periodicamente
+    """
+
+    st.success(conclusions)
+
+else:
+    st.error(
+        "❌ Erro ao carregar os dados. Verifique se o arquivo hotel_bookings.csv está presente no diretório."
+    )
+
+# =============================
+# Footer
+# =============================
+
+st.markdown("---")
+st.caption("PPCA/UnB | Novembro 2025")

questao-3/online_retail_II.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a000db4167982e3f929cc7c2051a8fd5969944c1a4986d14c88a7b03eb9e326
+size 45628546

questao-3/src/streamlit_app.py

@@ -0,0 +1,642 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import warnings
+
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import statsmodels.formula.api as smf
+import streamlit as st
+from scipy import stats
+from statsmodels.stats.anova import anova_lm
+from statsmodels.stats.stattools import durbin_watson
+
+warnings.filterwarnings("ignore")
+
+st.set_page_config(
+    page_title="Questão 3 - ANOVA",
+    page_icon="📊",
+    layout="wide",
+)
+
+st.markdown("""
+# Questão 3 – ANOVA para Análise de Vendas de Varejo Online
+
+**Online Retail Dataset**
+
+- **Autor:** Hugo Honda
+- **Disciplina:** AEDI - PPCA/UnB
+- **Data:** Novembro 2025
+
+---
+
+## Objetivos da Análise
+
+1. **Análise Descritiva dos Dados**: Explorar padrões de vendas por país
+2. **Comparação entre Países (ANOVA)**: Testar diferenças significativas nas médias
+3. **Ajustes no Modelo de ANOVA**: Validar pressupostos estatísticos
+4. **Interpretação e Tomada de Decisão**: Fornecer insights para estratégia de negócio
+""")
+
+
+@st.cache_data
+def load_data():
+    """Carrega e prepara os dados do Online Retail Dataset"""
+    try:
+        df = pd.read_excel("online_retail_II.xlsx")
+
+        # Limpeza de dados
+        df_clean = df.dropna(subset=["Country", "Quantity", "Price"])
+        df_clean = df_clean[df_clean["Quantity"] > 0]
+        df_clean = df_clean[df_clean["Price"] > 0]
+
+        # Criar coluna de receita
+        df_clean["Revenue"] = df_clean["Quantity"] * df_clean["Price"]
+
+        # Filtrar países com número mínimo de observações
+        country_counts = df_clean["Country"].value_counts()
+        min_observations = 100
+        valid_countries = country_counts[country_counts >= min_observations].index
+        df_clean = df_clean[df_clean["Country"].isin(valid_countries)]
+
+        return df_clean
+    except FileNotFoundError as e:
+        st.error(
+            f"Erro ao carregar dados: {str(e)}\n\nVerifique se o arquivo online_retail_II.xlsx está presente."
+        )
+        return None
+    except Exception as e:
+        st.error(f"Erro inesperado ao carregar dados: {str(e)}")
+        return None
+
+
+df_clean = load_data()
+country_col, quantity_col, price_col = "Country", "Quantity", "Price"
+
+if df_clean is not None:
+    # =============================
+    # Sidebar - Controles
+    # =============================
+
+    st.sidebar.header("🎛️ Controles da Análise")
+
+    st.sidebar.subheader("Parâmetros da Análise")
+    top_n_countries = st.sidebar.slider("Número de países para análise:", 3, 15, 8)
+    alpha = st.sidebar.slider("Nível de significância (α):", 0.01, 0.10, 0.05, 0.01)
+
+    st.sidebar.subheader("Opções de Visualização")
+    show_eda = st.sidebar.checkbox("Mostrar análise exploratória", True)
+    show_assumptions = st.sidebar.checkbox("Mostrar validação de pressupostos", True)
+    show_detailed_anova = st.sidebar.checkbox("Mostrar análise detalhada", True)
+
+    # =============================
+    # Análise Exploratória
+    # =============================
+
+    if show_eda:
+        st.header("📊 Análise Descritiva dos Dados")
+
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Total de Observações", f"{len(df_clean):,}")
+        with col2:
+            st.metric("Países Únicos", df_clean[country_col].nunique())
+        with col3:
+            st.metric("Quantidade Média", f"{df_clean[quantity_col].mean():.2f}")
+        with col4:
+            st.metric("Receita Total", f"${df_clean['Revenue'].sum():,.0f}")
+
+        # Top países por volume de transações
+        top_countries_by_count = df_clean[country_col].value_counts().head(15)
+
+        fig_count = px.bar(
+            x=top_countries_by_count.index,
+            y=top_countries_by_count.values,
+            title="Top 15 Países por Número de Transações",
+            labels={"x": "País", "y": "Número de Transações"},
+            color=top_countries_by_count.values,
+            color_continuous_scale="Viridis",
+        )
+        fig_count.update_layout(showlegend=False)
+        st.plotly_chart(fig_count, use_container_width=True)
+
+        # Estatísticas descritivas por país (top 10)
+        top_countries_stats = df_clean[country_col].value_counts().head(10).index
+        df_top_stats = df_clean[df_clean[country_col].isin(top_countries_stats)]
+
+        stats_by_country = (
+            df_top_stats.groupby(country_col)
+            .agg(
+                {
+                    quantity_col: ["mean", "median", "std"],
+                    price_col: ["mean", "median", "std"],
+                    "Revenue": ["sum", "mean"],
+                }
+            )
+            .round(2)
+        )
+
+        with st.expander("📋 Ver estatísticas descritivas por país (Top 10)"):
+            st.dataframe(stats_by_country, use_container_width=True)
+
+        # Box plots
+        col1, col2 = st.columns(2)
+
+        with col1:
+            fig_box_qty = px.box(
+                df_top_stats,
+                x=country_col,
+                y=quantity_col,
+                title="Distribuição de Quantidade por País (Top 10)",
+                labels={country_col: "País", quantity_col: "Quantidade"},
+            )
+            fig_box_qty.update_xaxis(tickangle=45)
+            st.plotly_chart(fig_box_qty, use_container_width=True)
+
+        with col2:
+            fig_box_price = px.box(
+                df_top_stats,
+                x=country_col,
+                y=price_col,
+                title="Distribuição de Preço por País (Top 10)",
+                labels={country_col: "País", price_col: "Preço Unitário"},
+            )
+            fig_box_price.update_xaxis(tickangle=45)
+            st.plotly_chart(fig_box_price, use_container_width=True)
+
+    # =============================
+    # Análise ANOVA
+    # =============================
+
+    st.header("🔬 Análise de Variância (ANOVA)")
+
+    # Selecionar top N países para análise
+    top_countries_anova = (
+        df_clean[country_col].value_counts().head(top_n_countries).index
+    )
+    df_anova = df_clean[df_clean[country_col].isin(top_countries_anova)].copy()
+
+    st.info(f"""
+    **Configuração da Análise:**
+    - **Países selecionados**: {top_n_countries}
+    - **Total de observações**: {len(df_anova):,}
+    - **Nível de significância**: α = {alpha}
+    - **Hipótese nula (H₀)**: As médias entre os países são iguais
+    - **Hipótese alternativa (H₁)**: Pelo menos uma média é diferente
+    """)
+
+    # ANOVA para Quantidade
+    st.subheader("📦 ANOVA para Quantidade")
+
+    formula_quantity = f"{quantity_col} ~ C({country_col})"
+    model_quantity = smf.ols(formula=formula_quantity, data=df_anova).fit()
+    anova_table_quantity = anova_lm(model_quantity, typ=2)
+
+    st.dataframe(anova_table_quantity.style.format("{:.4f}"), use_container_width=True)
+
+    f_stat_q = anova_table_quantity.iloc[0]["F"]
+    p_value_q = anova_table_quantity.iloc[0]["PR(>F)"]
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("F-statistic", f"{f_stat_q:.4f}")
+    with col2:
+        st.metric("p-value", f"{p_value_q:.6f}")
+    with col3:
+        is_significant_q = p_value_q < alpha
+        st.metric(
+            "Resultado",
+            "✅ Significativo" if is_significant_q else "❌ Não Significativo",
+            f"α = {alpha}",
+        )
+
+    if is_significant_q:
+        st.success(f"""
+        **Conclusão**: Rejeitamos H₀ (p = {p_value_q:.6f} < {alpha})
+
+        Existe diferença estatisticamente significativa entre as médias de quantidade dos países analisados.
+        """)
+    else:
+        st.warning(f"""
+        **Conclusão**: Não rejeitamos H₀ (p = {p_value_q:.6f} ≥ {alpha})
+
+        Não há evidências suficientes para concluir que as médias de quantidade diferem entre os países.
+        """)
+
+    # ANOVA para Preço
+    st.subheader("💰 ANOVA para Preço Unitário")
+
+    formula_price = f"{price_col} ~ C({country_col})"
+    model_price = smf.ols(formula=formula_price, data=df_anova).fit()
+    anova_table_price = anova_lm(model_price, typ=2)
+
+    st.dataframe(anova_table_price.style.format("{:.4f}"), use_container_width=True)
+
+    f_stat_p = anova_table_price.iloc[0]["F"]
+    p_value_p = anova_table_price.iloc[0]["PR(>F)"]
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("F-statistic", f"{f_stat_p:.4f}")
+    with col2:
+        st.metric("p-value", f"{p_value_p:.6f}")
+    with col3:
+        is_significant_p = p_value_p < alpha
+        st.metric(
+            "Resultado",
+            "✅ Significativo" if is_significant_p else "❌ Não Significativo",
+            f"α = {alpha}",
+        )
+
+    if is_significant_p:
+        st.success(f"""
+        **Conclusão**: Rejeitamos H₀ (p = {p_value_p:.6f} < {alpha})
+
+        Existe diferença estatisticamente significativa entre as médias de preço dos países analisados.
+        """)
+    else:
+        st.warning(f"""
+        **Conclusão**: Não rejeitamos H₀ (p = {p_value_p:.6f} ≥ {alpha})
+
+        Não há evidências suficientes para concluir que as médias de preço diferem entre os países.
+        """)
+
+    # ANOVA para Receita
+    st.subheader("💵 ANOVA para Receita")
+
+    formula_revenue = f"Revenue ~ C({country_col})"
+    model_revenue = smf.ols(formula=formula_revenue, data=df_anova).fit()
+    anova_table_revenue = anova_lm(model_revenue, typ=2)
+
+    st.dataframe(anova_table_revenue.style.format("{:.4f}"), use_container_width=True)
+
+    f_stat_r = anova_table_revenue.iloc[0]["F"]
+    p_value_r = anova_table_revenue.iloc[0]["PR(>F)"]
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("F-statistic", f"{f_stat_r:.4f}")
+    with col2:
+        st.metric("p-value", f"{p_value_r:.6f}")
+    with col3:
+        is_significant_r = p_value_r < alpha
+        st.metric(
+            "Resultado",
+            "✅ Significativo" if is_significant_r else "❌ Não Significativo",
+            f"α = {alpha}",
+        )
+
+    if is_significant_r:
+        st.success(f"""
+        **Conclusão**: Rejeitamos H₀ (p = {p_value_r:.6f} < {alpha})
+
+        Existe diferença estatisticamente significativa entre as médias de receita dos países analisados.
+        """)
+    else:
+        st.warning(f"""
+        **Conclusão**: Não rejeitamos H₀ (p = {p_value_r:.6f} ≥ {alpha})
+
+        Não há evidências suficientes para concluir que as médias de receita diferem entre os países.
+        """)
+
+    # =============================
+    # Visualizações Comparativas
+    # =============================
+
+    st.subheader("📊 Visualizações Comparativas")
+
+    # Médias por país
+    means_by_country = (
+        df_anova.groupby(country_col)
+        .agg({quantity_col: "mean", price_col: "mean", "Revenue": "mean"})
+        .reset_index()
+    )
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        fig_means_qty = px.bar(
+            means_by_country,
+            x=country_col,
+            y=quantity_col,
+            title="Média de Quantidade por País",
+            labels={country_col: "País", quantity_col: "Quantidade Média"},
+            color=quantity_col,
+            color_continuous_scale="Blues",
+        )
+        fig_means_qty.update_xaxis(tickangle=45)
+        st.plotly_chart(fig_means_qty, use_container_width=True)
+
+    with col2:
+        fig_means_price = px.bar(
+            means_by_country,
+            x=country_col,
+            y=price_col,
+            title="Média de Preço por País",
+            labels={country_col: "País", price_col: "Preço Médio"},
+            color=price_col,
+            color_continuous_scale="Greens",
+        )
+        fig_means_price.update_xaxis(tickangle=45)
+        st.plotly_chart(fig_means_price, use_container_width=True)
+
+    # Receita média por país
+    fig_means_revenue = px.bar(
+        means_by_country,
+        x=country_col,
+        y="Revenue",
+        title="Média de Receita por País",
+        labels={country_col: "País", "Revenue": "Receita Média"},
+        color="Revenue",
+        color_continuous_scale="Reds",
+    )
+    fig_means_revenue.update_xaxis(tickangle=45)
+    st.plotly_chart(fig_means_revenue, use_container_width=True)
+
+    # =============================
+    # Validação de Pressupostos
+    # =============================
+
+    if show_assumptions:
+        st.header("🔍 Validação dos Pressupostos da ANOVA")
+
+        st.markdown("""
+        A ANOVA requer três pressupostos principais:
+        1. **Normalidade**: Os resíduos devem seguir distribuição normal
+        2. **Homocedasticidade**: Variâncias iguais entre grupos
+        3. **Independência**: Observações independentes entre si
+        """)
+
+        # Pressupostos para Quantidade
+        st.subheader("📦 Pressupostos para Quantidade")
+
+        residuals_q = model_quantity.resid
+        groups_q = [g[quantity_col].values for _, g in df_anova.groupby(country_col)]
+
+        # Teste de Levene para homocedasticidade
+        levene_stat_q, levene_p_q = stats.levene(*groups_q, center="mean")
+        levene_ok_q = levene_p_q > alpha
+        
+        # Teste de Durbin-Watson para independência
+        dw_stat_q = durbin_watson(residuals_q)
+        dw_ok_q = 1.5 < dw_stat_q < 2.5
+        
+        # Teste de normalidade (Shapiro-Wilk em amostra)
+        sample_residuals_q = residuals_q if len(residuals_q) <= 5000 else residuals_q.sample(5000, random_state=42)
+        shapiro_stat_q, shapiro_p_q = stats.shapiro(sample_residuals_q)
+        shapiro_ok_q = shapiro_p_q > alpha
+
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Homocedasticidade (Levene)", "✅ OK" if levene_ok_q else "❌ Violado", f"p = {levene_p_q:.4f}")
+        with col2:
+            st.metric("Independência (Durbin-Watson)", "✅ OK" if dw_ok_q else "⚠️ Atenção", f"DW = {dw_stat_q:.4f}")
+        with col3:
+            st.metric("Normalidade (Shapiro-Wilk)", "✅ OK" if shapiro_ok_q else "❌ Violado", f"p = {shapiro_p_q:.4f}")
+
+        # Visualizações dos resíduos - Quantidade
+        col1, col2 = st.columns(2)
+
+        with col1:
+            fig_resid_q = px.histogram(
+                x=residuals_q,
+                nbins=50,
+                title="Distribuição dos Resíduos - Quantidade",
+                labels={"x": "Resíduos", "y": "Frequência"},
+            )
+            fig_resid_q.update_layout(showlegend=False)
+            st.plotly_chart(fig_resid_q, use_container_width=True)
+
+        with col2:
+            # Q-Q Plot
+            (osm, osr), (slope, intercept, r) = stats.probplot(residuals_q, dist="norm")
+
+            fig_qq_q = go.Figure()
+            fig_qq_q.add_trace(
+                go.Scatter(
+                    x=osm,
+                    y=osr,
+                    mode="markers",
+                    name="Resíduos",
+                    marker=dict(color="blue", opacity=0.5),
+                )
+            )
+            fig_qq_q.add_trace(
+                go.Scatter(
+                    x=osm,
+                    y=slope * osm + intercept,
+                    mode="lines",
+                    name="Linha teórica",
+                    line=dict(color="red", dash="dash"),
+                )
+            )
+            fig_qq_q.update_layout(
+                title="Q-Q Plot - Quantidade",
+                xaxis_title="Quantis Teóricos",
+                yaxis_title="Quantis da Amostra",
+            )
+            st.plotly_chart(fig_qq_q, use_container_width=True)
+
+        # Pressupostos para Preço
+        st.subheader("💰 Pressupostos para Preço")
+
+        residuals_p = model_price.resid
+        groups_p = [g[price_col].values for _, g in df_anova.groupby(country_col)]
+
+        levene_stat_p, levene_p_p = stats.levene(*groups_p, center="mean")
+        levene_ok_p = levene_p_p > alpha
+        
+        dw_stat_p = durbin_watson(residuals_p)
+        dw_ok_p = 1.5 < dw_stat_p < 2.5
+        
+        sample_residuals_p = residuals_p if len(residuals_p) <= 5000 else residuals_p.sample(5000, random_state=42)
+        shapiro_stat_p, shapiro_p_p = stats.shapiro(sample_residuals_p)
+        shapiro_ok_p = shapiro_p_p > alpha
+
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Homocedasticidade (Levene)", "✅ OK" if levene_ok_p else "❌ Violado", f"p = {levene_p_p:.4f}")
+        with col2:
+            st.metric("Independência (Durbin-Watson)", "✅ OK" if dw_ok_p else "⚠️ Atenção", f"DW = {dw_stat_p:.4f}")
+        with col3:
+            st.metric("Normalidade (Shapiro-Wilk)", "✅ OK" if shapiro_ok_p else "❌ Violado", f"p = {shapiro_p_p:.4f}")
+
+        # Resumo dos pressupostos
+        st.subheader("✅ Resumo da Validação")
+
+        assumptions_df = pd.DataFrame(
+            {
+                "Variável": [
+                    "Quantidade",
+                    "Quantidade",
+                    "Quantidade",
+                    "Preço",
+                    "Preço",
+                    "Preço",
+                ],
+                "Pressuposto": ["Homocedasticidade", "Independência", "Normalidade"]
+                * 2,
+                "Status": [
+                    "✅ Atendido" if levene_ok_q else "❌ Violado",
+                    "✅ Atendido" if dw_ok_q else "⚠️ Atenção",
+                    "✅ Atendido" if shapiro_ok_q else "❌ Violado",
+                    "✅ Atendido" if levene_ok_p else "❌ Violado",
+                    "✅ Atendido" if dw_ok_p else "⚠️ Atenção",
+                    "✅ Atendido" if shapiro_ok_p else "❌ Violado",
+                ],
+                "Teste/Valor": [
+                    f"Levene (p={levene_p_q:.4f})",
+                    f"DW={dw_stat_q:.4f}",
+                    f"Shapiro (p={shapiro_p_q:.4f})",
+                    f"Levene (p={levene_p_p:.4f})",
+                    f"DW={dw_stat_p:.4f}",
+                    f"Shapiro (p={shapiro_p_p:.4f})",
+                ],
+            }
+        )
+
+        st.dataframe(assumptions_df, use_container_width=True)
+
+        if not (levene_ok_q and shapiro_ok_q) or not (levene_ok_p and shapiro_ok_p):
+            st.warning("""
+            ⚠️ **Nota sobre violação de pressupostos:**
+
+            Quando os pressupostos são violados, considere:
+            - Transformação de dados (log, sqrt, Box-Cox)
+            - Testes não-paramétricos (Kruskal-Wallis)
+            - Aumentar tamanho da amostra (Teorema do Limite Central)
+            - ANOVA é robusta a pequenas violações com amostras grandes
+            """)
+
+    # =============================
+    # Análise Detalhada
+    # =============================
+
+    if show_detailed_anova:
+        st.header("📈 Análise Detalhada")
+
+        # Sumário dos modelos
+        with st.expander("📋 Ver sumário completo do modelo - Quantidade"):
+            st.text(model_quantity.summary())
+
+        with st.expander("📋 Ver sumário completo do modelo - Preço"):
+            st.text(model_price.summary())
+
+        with st.expander("📋 Ver sumário completo do modelo - Receita"):
+            st.text(model_revenue.summary())
+
+    # =============================
+    # Resumo e Tomada de Decisão
+    # =============================
+
+    st.header("📋 Resumo e Tomada de Decisão")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("🎯 Resultados da ANOVA")
+        results_df = pd.DataFrame(
+            {
+                "Variável": ["Quantidade", "Preço", "Receita"],
+                "F-statistic": [
+                    f"{f_stat_q:.4f}",
+                    f"{f_stat_p:.4f}",
+                    f"{f_stat_r:.4f}",
+                ],
+                "p-value": [f"{p_value_q:.6f}", f"{p_value_p:.6f}", f"{p_value_r:.6f}"],
+                "Significativo": [
+                    "✅ Sim" if is_significant_q else "❌ Não",
+                    "✅ Sim" if is_significant_p else "❌ Não",
+                    "✅ Sim" if is_significant_r else "❌ Não",
+                ],
+            }
+        )
+        st.dataframe(results_df, use_container_width=True)
+
+    with col2:
+        st.subheader("✅ Status dos Pressupostos")
+        if show_assumptions:
+            pressupostos_summary = pd.DataFrame(
+                {
+                    "Variável": ["Quantidade", "Preço"],
+                    "Homocedasticidade": [
+                        "✅" if levene_ok_q else "❌",
+                        "✅" if levene_ok_p else "❌",
+                    ],
+                    "Independência": [
+                        "✅" if dw_ok_q else "⚠️",
+                        "✅" if dw_ok_p else "⚠️",
+                    ],
+                    "Normalidade": [
+                        "✅" if shapiro_ok_q else "❌",
+                        "✅" if shapiro_ok_p else "❌",
+                    ],
+                }
+            )
+            st.dataframe(pressupostos_summary, use_container_width=True)
+        else:
+            st.info(
+                "Ative 'Mostrar validação de pressupostos' para ver o status detalhado."
+            )
+
+    st.subheader("🔍 Principais Conclusões e Recomendações")
+
+    conclusions = f"""
+    **Análise ANOVA - Vendas de Varejo Online:**
+
+    1. **Quantidade**: {"✅ Diferenças significativas detectadas" if is_significant_q else "❌ Sem diferenças significativas"} (p = {p_value_q:.6f})
+    2. **Preço**: {"✅ Diferenças significativas detectadas" if is_significant_p else "❌ Sem diferenças significativas"} (p = {p_value_p:.6f})
+    3. **Receita**: {"✅ Diferenças significativas detectadas" if is_significant_r else "❌ Sem diferenças significativas"} (p = {p_value_r:.6f})
+
+    **Implicações para o Negócio:**
+    """
+
+    if is_significant_q or is_significant_p or is_significant_r:
+        conclusions += """
+    - **Estratégia Diferenciada**: Implementar estratégias específicas por país
+    - **Precificação Regional**: Ajustar preços baseado em comportamento local
+    - **Alocação de Recursos**: Priorizar países com maior potencial
+    - **Marketing Direcionado**: Campanhas customizadas por mercado
+        """
+    else:
+        conclusions += """
+    - **Estratégia Uniforme**: Manter estratégia global consistente
+    - **Precificação Padronizada**: Preços uniformes são adequados
+    - **Eficiência Operacional**: Processos padronizados entre países
+        """
+
+    conclusions += f"""
+
+    **Recomendações Técnicas:**
+    - Nível de confiança: {(1 - alpha) * 100:.0f}%
+    - Países analisados: {top_n_countries}
+    - Total de observações: {len(df_anova):,}
+    """
+
+    if show_assumptions:
+        all_ok_q = levene_ok_q and dw_ok_q and shapiro_ok_q
+        all_ok_p = levene_ok_p and dw_ok_p and shapiro_ok_p
+
+        if not (all_ok_q and all_ok_p):
+            conclusions += (
+                "\n- ⚠️ Considerar transformação de dados ou testes não-paramétricos"
+            )
+        else:
+            conclusions += (
+                "\n- ✅ Todos os pressupostos atendidos, resultados confiáveis"
+            )
+
+    st.success(conclusions)
+
+else:
+    st.error(
+        "❌ Erro ao carregar os dados. Verifique se os arquivos de dados estão presentes no diretório."
+    )
+
+# =============================
+# Footer
+# =============================
+
+st.markdown("---")
+st.caption("PPCA/UnB | Novembro 2025")

marketing_campaign.csv → questao-4/credit_customers.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cd0affa36b1b981e80ba0e27767e9b3ab723f7a3dba948f722af81abc6b990ea
-size 220188
+oid sha256:d0baf9fddd41e5a6af0ba84e6037a415f11384dd40c494186563a2d3b68f5c25
+size 153016

questao-4/src/streamlit_app.py

@@ -0,0 +1,912 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import warnings
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import streamlit as st
+from imblearn.over_sampling import SMOTE
+from sklearn.cluster import DBSCAN, KMeans
+from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import (
+    accuracy_score,
+    calinski_harabasz_score,
+    confusion_matrix,
+    davies_bouldin_score,
+    f1_score,
+    precision_score,
+    recall_score,
+    roc_auc_score,
+    roc_curve,
+    silhouette_score,
+)
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+from sklearn.tree import DecisionTreeClassifier
+from xgboost import XGBClassifier
+
+try:
+    import shap
+
+    SHAP_AVAILABLE = True
+except ImportError:
+    SHAP_AVAILABLE = False
+
+warnings.filterwarnings("ignore")
+
+st.set_page_config(
+    page_title="Questão 4 - Risco de Crédito",
+    page_icon="🏦",
+    layout="wide",
+)
+
+st.markdown("""
+# Questão 4 – Modelo Preditivo de Risco de Crédito
+
+**Credit Risk Dataset**
+
+- **Autor:** Hugo Honda
+- **Disciplina:** AEDI - PPCA/UnB
+- **Data:** Novembro 2025
+
+---
+
+## Objetivos da Análise
+
+1. **Discussão sobre o Problema**: Contextualizar importância da gestão de risco
+2. **Análise Descritiva dos Dados**: Explorar características dos clientes
+3. **Definição e Seleção dos Modelos**: Comparar múltiplos algoritmos de ML
+4. **Explicabilidade das Variáveis - SHAP**: Interpretar decisões do modelo
+5. **Análise Não Supervisionada**: Identificar perfis de clientes via clustering
+6. **Tomada de Decisão Estratégica**: Fornecer insights acionáveis
+""")
+
+
+@st.cache_data
+def load_data():
+    """Carrega e prepara os dados do Credit Risk Dataset"""
+    try:
+        df = pd.read_csv("credit_customers.csv")
+
+        # Mapear target para binário
+        df["class"] = df["class"].map({"good": 0, "bad": 1})
+
+        # Tratar valores ausentes
+        numeric_cols = df.select_dtypes(include=[np.number]).columns
+        for col in numeric_cols:
+            if df[col].isnull().sum() > 0:
+                df[col].fillna(df[col].median(), inplace=True)
+
+        categorical_cols = df.select_dtypes(include=["object"]).columns
+        for col in categorical_cols:
+            if df[col].isnull().sum() > 0:
+                df[col].fillna(df[col].mode()[0], inplace=True)
+
+        return df
+    except FileNotFoundError as e:
+        st.error(
+            f"Erro ao carregar dados: {str(e)}\n\nVerifique se o arquivo credit_customers.csv está presente."
+        )
+        return None
+    except Exception as e:
+        st.error(f"Erro inesperado ao carregar dados: {str(e)}")
+        return None
+
+
+df = load_data()
+target_col = "class"
+
+if df is not None:
+    # =============================
+    # Sidebar - Controles
+    # =============================
+
+    st.sidebar.header("🎛️ Controles da Análise")
+
+    st.sidebar.subheader("Parâmetros do Modelo")
+    test_size = st.sidebar.slider("Tamanho do conjunto de teste:", 0.1, 0.4, 0.2, 0.05)
+    random_state = st.sidebar.number_input("Random State:", 1, 1000, 42)
+    use_smote = st.sidebar.checkbox("Usar SMOTE para balanceamento", True)
+
+    st.sidebar.subheader("Seleção de Modelos")
+    use_logistic = st.sidebar.checkbox("Logistic Regression", True)
+    use_decision_tree = st.sidebar.checkbox("Decision Tree", True)
+    use_random_forest = st.sidebar.checkbox("Random Forest", True)
+    use_xgboost = st.sidebar.checkbox("XGBoost", True)
+    use_gradient_boosting = st.sidebar.checkbox("Gradient Boosting", False)
+
+    st.sidebar.subheader("Opções de Visualização")
+    show_discussion = st.sidebar.checkbox("Mostrar discussão do problema", True)
+    show_eda = st.sidebar.checkbox("Mostrar análise exploratória", True)
+    show_shap = (
+        st.sidebar.checkbox("Mostrar análise SHAP", True) if SHAP_AVAILABLE else False
+    )
+    show_clustering = st.sidebar.checkbox("Mostrar análise de clustering", True)
+
+    # =============================
+    # Discussão sobre o Problema
+    # =============================
+
+    if show_discussion:
+        st.header("💡 Discussão sobre o Problema de Risco de Crédito")
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.markdown("""
+            ### 📌 Importância no Setor Bancário
+
+            **1. Redução de Perdas Financeiras**
+            - Identificar clientes com alto risco de inadimplência
+            - Evitar perdas significativas para a instituição
+            - Proteger o capital e liquidez do banco
+
+            **2. Gestão de Carteira de Crédito**
+            - Melhorar qualidade da carteira de empréstimos
+            - Otimizar alocação de recursos
+            - Balancear risco e retorno
+
+            **3. Decisões Estratégicas**
+            - Concessão de empréstimos
+            - Definição de limites de crédito
+            - Políticas de cobrança
+            - Taxas de juros personalizadas
+            """)
+
+        with col2:
+            st.markdown("""
+            ### 🎯 Por que Prever Inadimplência é Essencial
+
+            **1. Prevenção de Perdas**
+            - Antecipar problemas antes que ocorram
+            - Tomar ações preventivas
+            - Reduzir taxa de inadimplência
+
+            **2. Otimização de Recursos**
+            - Focar esforços de cobrança onde necessário
+            - Alocar recursos de forma eficiente
+            - Automatizar decisões de baixo risco
+
+            **3. Conformidade Regulatória**
+            - Atender requisitos de Basileia III
+            - Gerenciar capital regulatório
+            - Demonstrar governança de risco
+
+            **4. Vantagem Competitiva**
+            - Oferecer produtos adequados
+            - Melhor experiência ao cliente
+            - Reduzir custos operacionais
+            """)
+
+        st.info("""
+        **Impacto Econômico:** A gestão eficaz de risco de crédito não apenas protege a instituição financeira,
+        mas também contribui para a estabilidade do sistema financeiro como um todo, reduzindo a inadimplência
+        sistêmica e promovendo crescimento econômico sustentável.
+        """)
+
+    # =============================
+    # Análise Exploratória
+    # =============================
+
+    if show_eda:
+        st.header("📊 Análise Descritiva dos Dados")
+
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Total de Observações", f"{len(df):,}")
+        with col2:
+            default_rate = df[target_col].mean()
+            st.metric("Taxa de Inadimplência", f"{default_rate:.2%}")
+        with col3:
+            st.metric("Total de Features", len(df.columns) - 1)
+        with col4:
+            numeric_features = df.select_dtypes(include=[np.number]).columns
+            st.metric("Features Numéricas", len(numeric_features) - 1)
+
+        # Distribuição da variável target
+        target_counts = df[target_col].value_counts()
+
+            fig_target = go.Figure(
+                data=[
+                    go.Pie(
+                        labels=["Bom Pagador", "Mau Pagador"],
+                        values=target_counts.values,
+                        hole=0.4,
+                        marker_colors=["#00CC96", "#EF553B"],
+                    )
+                ]
+            )
+            fig_target.update_layout(title="Distribuição de Classes")
+            st.plotly_chart(fig_target, use_container_width=True)
+
+            # Análise de balanceamento
+            balance_ratio = target_counts.min() / target_counts.max()
+            if balance_ratio < 0.5:
+                st.warning(f"""
+                ⚠️ **Desbalanceamento de Classes Detectado**
+
+                - Razão de balanceamento: {balance_ratio:.2%}
+                - Recomendação: Usar técnicas de balanceamento (SMOTE, class_weight)
+                """)
+            else:
+                st.success("✅ Classes relativamente balanceadas")
+
+        # Estatísticas descritivas
+        with st.expander("📋 Ver estatísticas descritivas"):
+            st.dataframe(df.describe(), use_container_width=True)
+
+    # =============================
+    # Preparação dos Dados
+    # =============================
+
+    st.header("🔬 Definição e Seleção dos Modelos")
+
+    # Preparar dados
+    df_clean = df.copy()
+    categorical_cols = df_clean.select_dtypes(include=["object"]).columns
+    le_dict = {}
+
+    for col in categorical_cols:
+        if col != target_col:
+            le = LabelEncoder()
+            df_clean[col] = le.fit_transform(df_clean[col].astype(str))
+            le_dict[col] = le
+
+    all_features = [col for col in df_clean.columns if col != target_col]
+    X = df_clean[all_features].copy()
+    y = df_clean[target_col].copy()
+
+    # Divisão treino-teste
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_size, random_state=random_state, stratify=y
+    )
+
+    # Normalização
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+
+    # Balanceamento com SMOTE
+    if use_smote:
+        smote = SMOTE(random_state=random_state)
+        X_train_balanced, y_train_balanced = smote.fit_resample(X_train_scaled, y_train)
+        st.info(
+            f"✅ SMOTE aplicado: {len(X_train_scaled)} → {len(X_train_balanced)} amostras de treino"
+        )
+    else:
+        X_train_balanced, y_train_balanced = X_train_scaled, y_train
+
+    # =============================
+    # Treinamento dos Modelos
+    # =============================
+
+    st.subheader("🤖 Treinamento e Comparação de Modelos")
+
+    models = {}
+
+    if use_logistic:
+        models["Logistic Regression"] = LogisticRegression(
+            random_state=random_state, max_iter=1000
+        )
+    if use_decision_tree:
+        models["Decision Tree"] = DecisionTreeClassifier(
+            random_state=random_state, max_depth=10
+        )
+    if use_random_forest:
+        models["Random Forest"] = RandomForestClassifier(
+            random_state=random_state, n_estimators=100, max_depth=10
+        )
+    if use_xgboost:
+        models["XGBoost"] = XGBClassifier(
+            random_state=random_state, eval_metric="logloss", n_estimators=100
+        )
+    if use_gradient_boosting:
+        models["Gradient Boosting"] = GradientBoostingClassifier(
+            random_state=random_state, n_estimators=100
+        )
+
+    if not models:
+        st.warning("⚠️ Selecione pelo menos um modelo para treinar.")
+    else:
+        results = {}
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+
+        for i, (name, model) in enumerate(models.items()):
+            status_text.text(f"Treinando {name}...")
+
+            model.fit(X_train_balanced, y_train_balanced)
+            y_pred = model.predict(X_test_scaled)
+            y_pred_proba = model.predict_proba(X_test_scaled)[:, 1]
+
+            results[name] = {
+                "accuracy": accuracy_score(y_test, y_pred),
+                "precision": precision_score(y_test, y_pred, zero_division=0),
+                "recall": recall_score(y_test, y_pred, zero_division=0),
+                "f1": f1_score(y_test, y_pred, zero_division=0),
+                "roc_auc": roc_auc_score(y_test, y_pred_proba),
+                "model": model,
+                "y_pred": y_pred,
+                "y_pred_proba": y_pred_proba,
+            }
+
+            progress_bar.progress((i + 1) / len(models))
+
+        status_text.text("✅ Treinamento concluído!")
+        progress_bar.empty()
+
+        # =============================
+        # Comparação de Modelos
+        # =============================
+
+        st.subheader("📈 Comparação de Performance dos Modelos")
+
+        comparison_df = pd.DataFrame(
+            {
+                name: {
+                    "Accuracy": f"{data['accuracy']:.4f}",
+                    "Precision": f"{data['precision']:.4f}",
+                    "Recall": f"{data['recall']:.4f}",
+                    "F1-Score": f"{data['f1']:.4f}",
+                    "AUC-ROC": f"{data['roc_auc']:.4f}",
+                }
+                for name, data in results.items()
+            }
+        ).T
+
+        st.dataframe(
+            comparison_df.style.highlight_max(axis=0, color="lightgreen"),
+            use_container_width=True,
+        )
+
+        # Identificar melhor modelo
+        best_model_name = max(results, key=lambda x: results[x]["roc_auc"])
+        best_model = results[best_model_name]["model"]
+        best_auc = results[best_model_name]["roc_auc"]
+
+        st.success(f"🏆 **Melhor Modelo: {best_model_name}** (AUC-ROC: {best_auc:.4f})")
+
+        # Visualização comparativa
+        metrics_for_plot = pd.DataFrame(
+            {
+                name: [
+                    data["accuracy"],
+                    data["precision"],
+                    data["recall"],
+                    data["f1"],
+                    data["roc_auc"],
+                ]
+                for name, data in results.items()
+            },
+            index=["Accuracy", "Precision", "Recall", "F1-Score", "AUC-ROC"],
+        ).T.reset_index()
+        metrics_for_plot.columns = ["Model"] + list(metrics_for_plot.columns[1:])
+
+        fig_comparison = go.Figure()
+        for metric in ["Accuracy", "Precision", "Recall", "F1-Score", "AUC-ROC"]:
+            fig_comparison.add_trace(
+                go.Bar(
+                    name=metric, x=metrics_for_plot["Model"], y=metrics_for_plot[metric]
+                )
+            )
+
+        fig_comparison.update_layout(
+            title="Comparação de Métricas por Modelo",
+            xaxis_title="Modelo",
+            yaxis_title="Score",
+            barmode="group",
+            height=500,
+        )
+        st.plotly_chart(fig_comparison, use_container_width=True)
+
+        # =============================
+        # Matriz de Confusão
+        # =============================
+
+        st.subheader("📊 Matriz de Confusão - Melhor Modelo")
+
+        cm = confusion_matrix(y_test, results[best_model_name]["y_pred"])
+
+        fig_cm = px.imshow(
+            cm,
+            labels=dict(x="Predito", y="Real", color="Quantidade"),
+            x=["Bom Pagador", "Mau Pagador"],
+            y=["Bom Pagador", "Mau Pagador"],
+            text_auto=True,
+            title=f"Matriz de Confusão - {best_model_name}",
+            color_continuous_scale="Blues",
+        )
+        st.plotly_chart(fig_cm, use_container_width=True)
+
+        tn, fp, fn, tp = cm.ravel()
+
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric(
+                "Verdadeiros Positivos (TP)",
+                tp,
+                help="Maus pagadores corretamente identificados",
+            )
+        with col2:
+            st.metric(
+                "Verdadeiros Negativos (TN)",
+                tn,
+                help="Bons pagadores corretamente identificados",
+            )
+        with col3:
+            st.metric(
+                "Falsos Positivos (FP)",
+                fp,
+                help="Bons pagadores classificados como maus",
+            )
+        with col4:
+            st.metric(
+                "Falsos Negativos (FN)",
+                fn,
+                help="Maus pagadores não identificados (CRÍTICO)",
+            )
+
+        # Custo de erro
+        st.info(f"""
+        **Análise de Custo:**
+        - **Falsos Negativos ({fn})**: Maior risco! Maus pagadores não identificados podem causar perdas significativas
+        - **Falsos Positivos ({fp})**: Oportunidade perdida! Bons clientes podem ser rejeitados
+        - **Taxa de Identificação de Maus Pagadores**: {results[best_model_name]["recall"]:.2%} (Recall)
+        """)
+
+        # =============================
+        # Curva ROC
+        # =============================
+
+        st.subheader("📈 Curva ROC - Comparação de Modelos")
+
+        fig_roc = go.Figure()
+
+        for name, data in results.items():
+            fpr, tpr, _ = roc_curve(y_test, data["y_pred_proba"])
+            fig_roc.add_trace(
+                go.Scatter(
+                    x=fpr,
+                    y=tpr,
+                    mode="lines",
+                    name=f"{name} (AUC={data['roc_auc']:.4f})",
+                    line=dict(width=2),
+                )
+            )
+
+        fig_roc.add_trace(
+            go.Scatter(
+                x=[0, 1],
+                y=[0, 1],
+                mode="lines",
+                name="Aleatório",
+                line=dict(color="red", width=2, dash="dash"),
+            )
+        )
+
+        fig_roc.update_layout(
+            title="Curva ROC - Receiver Operating Characteristic",
+            xaxis_title="Taxa de Falsos Positivos (FPR)",
+            yaxis_title="Taxa de Verdadeiros Positivos (TPR)",
+            height=600,
+        )
+
+        st.plotly_chart(fig_roc, use_container_width=True)
+
+        # =============================
+        # Análise SHAP
+        # =============================
+
+        if show_shap and SHAP_AVAILABLE:
+            st.header("🔍 Explicabilidade das Variáveis (SHAP)")
+
+            st.markdown("""
+            **SHAP (SHapley Additive exPlanations)** é uma abordagem de teoria dos jogos para explicar
+            as predições de qualquer modelo de machine learning. Ele conecta teoria dos jogos com
+            explicabilidade local, atribuindo um valor de importância para cada feature.
+            """)
+
+            try:
+                # Verificar tipo de modelo para escolher explainer apropriado
+                is_tree_model = isinstance(
+                    best_model,
+                    (
+                        XGBClassifier,
+                        RandomForestClassifier,
+                        DecisionTreeClassifier,
+                        GradientBoostingClassifier,
+                    ),
+                )
+
+                with st.spinner("Calculando SHAP values..."):
+                    if is_tree_model:
+                        explainer = shap.TreeExplainer(best_model)
+                        shap_values = explainer.shap_values(X_test_scaled[:1000])
+                    elif isinstance(best_model, LogisticRegression):
+                        explainer = shap.LinearExplainer(
+                            best_model, X_train_scaled[:100]
+                        )
+                        shap_values = explainer.shap_values(X_test_scaled[:1000])
+                    else:
+                        explainer = shap.KernelExplainer(
+                            best_model.predict_proba, X_train_scaled[:100]
+                        )
+                        shap_values = explainer.shap_values(X_test_scaled[:100])
+
+                # Se shap_values é uma lista (para classificação binária), pegar o segundo elemento
+                if isinstance(shap_values, list):
+                    shap_values_to_plot = shap_values[1]
+                else:
+                    shap_values_to_plot = shap_values
+
+                st.subheader("📊 SHAP Summary Plot")
+
+                # Criar figura SHAP
+                import matplotlib.pyplot as plt
+
+                fig, ax = plt.subplots(figsize=(10, 8))
+                shap.summary_plot(
+                    shap_values_to_plot,
+                    X_test_scaled[:1000],
+                    feature_names=all_features,
+                    show=False,
+                    max_display=20,
+                )
+                st.pyplot(fig)
+                plt.close()
+
+                st.info("""
+                **Interpretação do SHAP Summary Plot:**
+                - **Eixo Y**: Features ordenadas por importância (mais importante no topo)
+                - **Eixo X**: Impacto no modelo (valores positivos aumentam probabilidade de inadimplência)
+                - **Cor**: Valor da feature (vermelho = alto, azul = baixo)
+                - **Dispersão**: Mostra o efeito de diferentes valores da feature
+                """)
+
+                # SHAP Feature Importance
+                st.subheader("🎯 Importância das Features (SHAP)")
+
+                shap_importance = np.abs(shap_values_to_plot).mean(axis=0)
+                importance_df = (
+                    pd.DataFrame(
+                        {"Feature": all_features, "Importance": shap_importance}
+                    )
+                    .sort_values("Importance", ascending=False)
+                    .head(20)
+                )
+
+                fig_shap_imp = px.bar(
+                    importance_df,
+                    x="Importance",
+                    y="Feature",
+                    orientation="h",
+                    title="Top 20 Features por Importância SHAP",
+                    color="Importance",
+                    color_continuous_scale="Viridis",
+                )
+                fig_shap_imp.update_layout(height=600)
+                st.plotly_chart(fig_shap_imp, use_container_width=True)
+
+            except Exception as e:
+                st.warning(
+                    f"⚠️ Erro ao calcular SHAP values: {str(e)}\n\nIsso pode ocorrer com alguns tipos de modelos."
+                )
+        elif show_shap and not SHAP_AVAILABLE:
+            st.warning("📦 SHAP não está instalado. Execute: `pip install shap`")
+
+        # Feature Importance alternativa (para modelos baseados em árvore)
+        if hasattr(best_model, "feature_importances_"):
+            st.subheader("🎯 Importância das Features (Modelo)")
+
+            feature_importance = (
+                pd.DataFrame(
+                    {
+                        "Feature": all_features,
+                        "Importance": best_model.feature_importances_,
+                    }
+                )
+                .sort_values("Importance", ascending=False)
+                .head(20)
+            )
+
+            fig_feat_imp = px.bar(
+                feature_importance,
+                x="Importance",
+                y="Feature",
+                orientation="h",
+                title=f"Top 20 Features Mais Importantes - {best_model_name}",
+                color="Importance",
+                color_continuous_scale="Viridis",
+            )
+            fig_feat_imp.update_layout(height=600)
+            st.plotly_chart(fig_feat_imp, use_container_width=True)
+
+        # =============================
+        # Análise de Clustering
+        # =============================
+
+        if show_clustering:
+            st.header("📊 Análise Não Supervisionada (Clustering)")
+
+            st.markdown("""
+            Clustering permite identificar grupos naturais de clientes com características similares,
+            independentemente do rótulo de inadimplência. Isso pode revelar perfis de risco não capturados
+            pela análise supervisionada.
+            """)
+
+            # Selecionar features para clustering (usar todas numéricas originais)
+            numeric_features_for_cluster = df.select_dtypes(
+                include=[np.number]
+            ).columns.tolist()
+            if target_col in numeric_features_for_cluster:
+                numeric_features_for_cluster.remove(target_col)
+
+            if len(numeric_features_for_cluster) >= 2:
+                X_cluster = df[numeric_features_for_cluster].copy()
+                X_cluster = X_cluster.fillna(X_cluster.median())
+                X_cluster_scaled = StandardScaler().fit_transform(X_cluster)
+
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    st.subheader("🔵 K-Means Clustering")
+
+                    n_clusters = st.slider("Número de clusters (K-Means):", 2, 10, 4)
+
+                    kmeans = KMeans(
+                        n_clusters=n_clusters, random_state=random_state, n_init=10
+                    )
+                    clusters_kmeans = kmeans.fit_predict(X_cluster_scaled)
+
+                    # Métricas de clustering
+                    silhouette_km = silhouette_score(X_cluster_scaled, clusters_kmeans)
+                    davies_bouldin_km = davies_bouldin_score(
+                        X_cluster_scaled, clusters_kmeans
+                    )
+                    calinski_km = calinski_harabasz_score(
+                        X_cluster_scaled, clusters_kmeans
+                    )
+
+                    st.metric(
+                        "Silhouette Score",
+                        f"{silhouette_km:.4f}",
+                        help="Maior é melhor (range: -1 a 1)",
+                    )
+                    st.metric(
+                        "Davies-Bouldin Index",
+                        f"{davies_bouldin_km:.4f}",
+                        help="Menor é melhor",
+                    )
+                    st.metric(
+                        "Calinski-Harabasz Score",
+                        f"{calinski_km:.2f}",
+                        help="Maior é melhor",
+                    )
+
+                    # Distribuição de clusters por classe
+                    df_kmeans = df.copy()
+                    df_kmeans["Cluster"] = clusters_kmeans
+
+                    cluster_class_dist = (
+                        pd.crosstab(
+                            df_kmeans["Cluster"],
+                            df_kmeans[target_col],
+                            normalize="index",
+                        )
+                        * 100
+                    )
+
+                    st.write("**Distribuição de Classes por Cluster (%):**")
+                    st.dataframe(cluster_class_dist.round(2), use_container_width=True)
+
+                with col2:
+                    st.subheader("🔴 DBSCAN Clustering")
+
+                    eps = st.slider("Epsilon (raio de vizinhança):", 0.1, 2.0, 0.5, 0.1)
+                    min_samples = st.slider("Mínimo de amostras:", 2, 20, 5)
+
+                    dbscan = DBSCAN(eps=eps, min_samples=min_samples)
+                    clusters_dbscan = dbscan.fit_predict(X_cluster_scaled)
+
+                    n_clusters_db = len(set(clusters_dbscan)) - (
+                        1 if -1 in clusters_dbscan else 0
+                    )
+                    n_outliers = (clusters_dbscan == -1).sum()
+
+                    st.metric("Número de Clusters", n_clusters_db)
+                    st.metric(
+                        "Outliers Detectados",
+                        n_outliers,
+                        help="Pontos classificados como -1",
+                    )
+                    st.metric(
+                        "% de Outliers",
+                        f"{(n_outliers / len(clusters_dbscan)) * 100:.2f}%",
+                    )
+
+                    if n_clusters_db > 1:
+                        # Calcular métricas apenas para pontos não-outliers
+                        mask_not_outliers = clusters_dbscan != -1
+                        if mask_not_outliers.sum() > n_clusters_db:
+                            silhouette_db = silhouette_score(
+                                X_cluster_scaled[mask_not_outliers],
+                                clusters_dbscan[mask_not_outliers],
+                            )
+                            st.metric("Silhouette Score", f"{silhouette_db:.4f}")
+
+                    # Análise de outliers
+                    if n_outliers > 0:
+                        df_dbscan = df.copy()
+                        df_dbscan["Cluster"] = clusters_dbscan
+                        outliers_default_rate = df_dbscan[df_dbscan["Cluster"] == -1][
+                            target_col
+                        ].mean()
+                        normal_default_rate = df_dbscan[df_dbscan["Cluster"] != -1][
+                            target_col
+                        ].mean()
+
+                        st.write(
+                            f"**Taxa de Inadimplência em Outliers:** {outliers_default_rate:.2%}"
+                        )
+                        st.write(
+                            f"**Taxa de Inadimplência em Clusters:** {normal_default_rate:.2%}"
+                        )
+
+                # Visualização 2D usando PCA
+                from sklearn.decomposition import PCA
+
+                pca = PCA(n_components=2)
+                X_pca = pca.fit_transform(X_cluster_scaled)
+
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    fig_kmeans_viz = px.scatter(
+                        x=X_pca[:, 0],
+                        y=X_pca[:, 1],
+                        color=clusters_kmeans.astype(str),
+                        title="Visualização K-Means (PCA 2D)",
+                        labels={
+                            "x": f"PC1 ({pca.explained_variance_ratio_[0]:.1%})",
+                            "y": f"PC2 ({pca.explained_variance_ratio_[1]:.1%})",
+                        },
+                        opacity=0.6,
+                    )
+                    fig_kmeans_viz.update_layout(height=500)
+                    st.plotly_chart(fig_kmeans_viz, use_container_width=True)
+
+                with col2:
+                    fig_dbscan_viz = px.scatter(
+                        x=X_pca[:, 0],
+                        y=X_pca[:, 1],
+                        color=clusters_dbscan.astype(str),
+                        title="Visualização DBSCAN (PCA 2D)",
+                        labels={
+                            "x": f"PC1 ({pca.explained_variance_ratio_[0]:.1%})",
+                            "y": f"PC2 ({pca.explained_variance_ratio_[1]:.1%})",
+                        },
+                        opacity=0.6,
+                    )
+                    fig_dbscan_viz.update_layout(height=500)
+                    st.plotly_chart(fig_dbscan_viz, use_container_width=True)
+
+                st.info(f"""
+                **Interpretação do Clustering:**
+                - **K-Means**: Identifica {n_clusters} grupos com características similares
+                - **DBSCAN**: Detecta {n_clusters_db} clusters densos e {n_outliers} outliers
+                - **Variância Explicada (PCA)**: {(pca.explained_variance_ratio_[0] + pca.explained_variance_ratio_[1]):.1%} com 2 componentes
+                - Os clusters podem representar perfis de risco distintos
+                """)
+            else:
+                st.warning("Número insuficiente de features numéricas para clustering.")
+
+        # =============================
+        # Tomada de Decisão Estratégica
+        # =============================
+
+        st.header("💼 Tomada de Decisão Estratégica")
+
+        st.markdown("""
+        ### 🎯 Recomendações Baseadas na Análise
+        """)
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.markdown(f"""
+            #### 📊 Insights do Modelo Preditivo
+
+            **Modelo Recomendado:** {best_model_name}
+            - **AUC-ROC:** {best_auc:.4f}
+            - **Recall (Detecção de Maus Pagadores):** {results[best_model_name]["recall"]:.2%}
+            - **Precisão:** {results[best_model_name]["precision"]:.2%}
+
+            **Aplicações Práticas:**
+            1. **Aprovação Automática**: Clientes de baixo risco
+            2. **Análise Manual**: Casos intermediários
+            3. **Rejeição ou Condições Especiais**: Alto risco
+            4. **Pricing Dinâmico**: Taxas baseadas em risco
+            """)
+
+        with col2:
+            st.markdown("""
+            #### 🎯 Estratégias de Mitigação de Risco
+
+            **Para Reduzir Falsos Negativos:**
+            - Ajustar threshold de decisão
+            - Implementar sistema de alertas
+            - Análise adicional de casos limítrofes
+
+            **Para Otimizar Receita:**
+            - Oferecer taxas ajustadas ao risco
+            - Programas de fidelidade para bons pagadores
+            - Produtos personalizados por perfil
+
+            **Monitoramento Contínuo:**
+            - Recalibrar modelo periodicamente
+            - Monitorar drift de dados
+            - Atualizar com novos dados
+            """)
+
+        # Resumo executivo
+        st.subheader("📋 Resumo Executivo")
+
+        summary_metrics = pd.DataFrame(
+            {
+                "Métrica": [
+                    "Total de Clientes Analisados",
+                    "Taxa de Inadimplência",
+                    "Melhor Modelo",
+                    "Performance (AUC-ROC)",
+                    "Taxa de Detecção",
+                    "Falsos Negativos (Risco)",
+                    "Clusters Identificados",
+                ],
+                "Valor": [
+                    f"{len(df):,}",
+                    f"{default_rate:.2%}",
+                    best_model_name,
+                    f"{best_auc:.4f}",
+                    f"{results[best_model_name]['recall']:.2%}",
+                    f"{fn} ({(fn / (fn + tp)) * 100:.1f}% dos maus pagadores)",
+                    f"{n_clusters if show_clustering and len(numeric_features_for_cluster) >= 2 else 'N/A'}",
+                ],
+            }
+        )
+
+        st.dataframe(summary_metrics, use_container_width=True)
+
+        st.success(f"""
+        **Conclusão Final:**
+
+        O modelo {best_model_name} demonstrou a melhor performance com AUC-ROC de {best_auc:.4f},
+        sendo capaz de identificar {results[best_model_name]["recall"]:.2%} dos maus pagadores.
+
+        **Impacto Estimado:**
+        - Redução potencial de inadimplência: {results[best_model_name]["recall"] * default_rate * 100:.1f}%
+        - Melhoria na qualidade da carteira de crédito
+        - Otimização da alocação de recursos de cobrança
+
+        **Próximos Passos:**
+        1. Implementar modelo em ambiente de produção
+        2. Estabelecer pipeline de monitoramento
+        3. Criar dashboards executivos
+        4. Treinar equipes para uso do sistema
+        5. Avaliar impacto financeiro em 6-12 meses
+        """)
+
+else:
+    st.error(
+        "❌ Erro ao carregar os dados. Verifique se o arquivo credit_customers.csv está presente no diretório."
+    )
+
+# =============================
+# Footer
+# =============================
+
+st.markdown("---")
+st.caption("PPCA/UnB | Novembro 2025")

requirements.txt

@@ -8,3 +8,6 @@ plotly
 statsmodels
 scipy
 imbalanced-learn
+xgboost
+shap
+openpyxl

src/streamlit_app.py

@@ -1,592 +1,247 @@
 #!/usr/bin/env python
 # coding: utf-8
 
-import warnings
-from collections import Counter
-
-import numpy as np
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
 import streamlit as st
-from imblearn.over_sampling import SMOTE
-from imblearn.pipeline import Pipeline as ImbPipeline
-from sklearn.compose import ColumnTransformer
-from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
-from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import (
-    accuracy_score,
-    auc,
-    average_precision_score,
-    balanced_accuracy_score,
-    confusion_matrix,
-    f1_score,
-    precision_recall_curve,
-    precision_score,
-    recall_score,
-    roc_auc_score,
-    roc_curve,
-)
-from sklearn.model_selection import (
-    GridSearchCV,
-    StratifiedKFold,
-    cross_val_score,
-    train_test_split,
-)
-from sklearn.pipeline import Pipeline
-from sklearn.preprocessing import OneHotEncoder, StandardScaler
-
-warnings.filterwarnings("ignore")
+from pathlib import Path
+import os
 
 st.set_page_config(
-    page_title="Análise de Personalidade de Consumidores - Reclamações",
-    page_icon="🧠",
+    page_title="Prova Final - AEDI",
+    page_icon="📊",
     layout="wide",
+    initial_sidebar_state="expanded",
 )
 
-st.markdown(
-    """
-# Tarefa 6 de AEDI - Análise de Personalidade de Consumidores
+st.markdown("""
+# Prova Final de Análise Estatística de Dados e Informações
 
-**Customer Personality Analysis** - Kaggle
+**Novembro - 2025**
 
 - **Autor:** Hugo Honda
 - **Disciplina:** AEDI - PPCA/UnB
-- **Data:** Outubro de 2025
 
-"""
-)
+---
 
-# =============================
-# Carregamento e preparação dos dados
-# =============================
-
-
-@st.cache_data
-def load_data():
-    """Carrega e prepara os dados de marketing_campaign.csv"""
-    # Auto-detecta separador
-    df = pd.read_csv("marketing_campaign.csv", sep=None, engine="python")
-
-    # Normalizar nomes de colunas
-    df.columns = [c.strip().replace(" ", "_") for c in df.columns]
-
-    # FIX 1: Correct age calculation using actual data collection year
-    if "Year_Birth" in df.columns and "Dt_Customer" in df.columns:
-        # Extract year from Dt_Customer to get actual data collection year
-        df["Dt_Customer"] = pd.to_datetime(df["Dt_Customer"], format="%d-%m-%Y")
-        df["Data_Year"] = df["Dt_Customer"].dt.year
-        # Use median year as reference for age calculation
-        reference_year = df["Data_Year"].median()
-        df["Age"] = reference_year - df["Year_Birth"]
-        print(f"Idade calculada usando ano de referência: {reference_year}")
-    elif "Year_Birth" in df.columns:
-        # Fallback: use 2014 as reference (middle of dataset range)
-        df["Age"] = 2014 - df["Year_Birth"]
-        print("Idade calculada usando ano de referência: 2014")
-
-    df["Total_Dependents"] = df["Kidhome"] + df["Teenhome"]
-
-    # FIX 2: Remove flawed conversion rate calculation
-    purchase_cols = [c for c in df.columns if "Purchases" in c and c.startswith("Num")]
-    if purchase_cols:
-        df["Total_Purchases"] = df[purchase_cols].sum(axis=1)
-        # Remove the problematic conversion rate that creates artificial correlation
-        print("Feature 'Conversion_Rate' removida - causava correlação artificial")
-
-    # FIX 3: Better missing value handling
-    df["Income"].fillna(df["Income"].median(), inplace=True)
-
-    # Age filtering with reasonable bounds
-    df = df[(df["Age"] >= 18) & (df["Age"] <= 100)]
-    df = df.dropna(subset=["Complain"])
-    df["Complain"] = df["Complain"].astype(int)
-
-    # Feature selection
-    feature_candidates = [
-        "Age",
-        "Income",
-        "Recency",
-        "MntWines",
-        "MntFruits",
-        "MntMeatProducts",
-        "MntFishProducts",
-        "MntSweetProducts",
-        "MntGoldProds",
-        "NumDealsPurchases",
-        "NumWebPurchases",
-        "NumCatalogPurchases",
-        "NumStorePurchases",
-        "NumWebVisitsMonth",
-        "Kidhome",
-        "Teenhome",
-        "Total_Dependents",
-        "Total_Purchases",  # Added total purchases instead of conversion rate
-        "Education",
-        "Marital_Status",
-    ]
-
-    features = [f for f in feature_candidates if f in df.columns]
-    numeric_features = [f for f in features if df[f].dtype in ["int64", "float64"]]
-    categorical_features = [f for f in features if df[f].dtype == "object"]
-
-    X = df[features].copy()
-    y = df["Complain"].copy()
-
-    # Preencher NaNs
-    for col in numeric_features:
-        if X[col].isnull().any():
-            X[col].fillna(X[col].median(), inplace=True)
-
-    for col in categorical_features:
-        if X[col].isnull().any():
-            X[col].fillna("Unknown", inplace=True)
-
-    return df, X, y, features, categorical_features, numeric_features
-
-
-# Carregar dados
-try:
-    df_raw, X, y, features, categorical_features, numeric_features = load_data()
-except Exception as e:
-    st.error(f"Erro ao carregar dados: {e}")
-    st.stop()
-
-# =============================
-# Sidebar - Controles
-# =============================
-
-st.sidebar.header("Controles da Análise")
-
-st.sidebar.subheader("Parâmetros do Modelo")
-show_eda = st.sidebar.checkbox("Mostrar EDA", True)
-test_size = st.sidebar.slider("Tamanho do conjunto de teste:", 0.1, 0.4, 0.15, 0.05)
-random_state = st.sidebar.number_input("Random State:", 1, 1000, 42)
-
-# =============================
-# EDA
-# =============================
-
-if show_eda:
-    st.header("Análise Exploratória")
-
-    col1, col2, col3 = st.columns(3)
-    with col1:
-        st.metric("Observações", len(df_raw))
-    with col2:
-        st.metric("Taxa de Queixas", f"{y.mean():.1%}")
-    with col3:
-        st.metric("Features", len(features))
-
-    # Enhanced pie chart with better styling
-    fig_target = px.pie(
-        values=y.value_counts().values,
-        names=["Sem Queixa", "Com Queixa"],
-        title="Distribuição de Queixas - Dataset Desbalanceado",
-        color_discrete_sequence=["#2E8B57", "#DC143C"],
-        hole=0.3,
-    )
-    fig_target.update_traces(textposition="inside", textinfo="percent+label")
-    fig_target.update_layout(
-        font_size=12,
-        showlegend=True,
-        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
-    )
-    st.plotly_chart(fig_target, use_container_width=True)
-
-    # Enhanced correlation analysis
-    numeric_cols = df_raw.select_dtypes(include=[np.number]).columns.tolist()
-    if "Complain" in numeric_cols:
-        corr_with_target = (
-            df_raw[numeric_cols].corr()["Complain"].sort_values(ascending=False)
-        )
-
-        st.subheader("Top 10 Correlações com Complain")
-        st.write(corr_with_target.head(11)[1:])
-
-        # Enhanced correlation visualization
-        top_corr = corr_with_target.head(11)[1:].abs().sort_values(ascending=True)
-
-        fig_corr = px.bar(
-            x=top_corr.values,
-            y=top_corr.index,
-            orientation="h",
-            title="Top 10 Correlações com Complain (Valor Absoluto)",
-            color=top_corr.values,
-            color_continuous_scale="RdBu_r",
-        )
-        fig_corr.update_layout(
-            xaxis_title="Correlação Absoluta",
-            yaxis_title="Features",
-            height=500,
-            coloraxis_showscale=False,
-        )
-        st.plotly_chart(fig_corr, use_container_width=True)
-
-        # Class distribution analysis
-        class_counts = Counter(y)
-        st.subheader("Distribuição de Classes")
-        st.write(
-            f"**Classe 0 (Sem queixa):** {class_counts[0]} ({class_counts[0] / len(y) * 100:.1f}%)"
-        )
-        st.write(
-            f"**Classe 1 (Com queixa):** {class_counts[1]} ({class_counts[1] / len(y) * 100:.1f}%)"
-        )
-
-# =============================
-# Modelagem Avançada
-# =============================
-
-st.header("Modelagem Avançada com Múltiplos Algoritmos")
-
-# FIX 6: Proper train/val/test split to avoid data leakage
-# Split into train (70%) / val (15%) / test (15%) for proper threshold tuning
-X_temp, X_test, y_temp, y_test = train_test_split(
-    X, y, test_size=0.15, random_state=random_state, stratify=y
-)
-X_train, X_val, y_train, y_val = train_test_split(
-    X_temp,
-    y_temp,
-    test_size=0.176,
-    random_state=random_state,
-    stratify=y_temp,  # 0.176 * 0.85 ≈ 0.15
-)
+## Navegação por Questões
 
-st.write(
-    f"**Features:** {len(features)} ({len(numeric_features)} numéricas, {len(categorical_features)} categóricas)"
-)
-st.write(
-    f"**Treino:** {X_train.shape[0]} | **Validação:** {X_val.shape[0]} | **Teste:** {X_test.shape[0]}"
-)
-st.write(
-    f"**Taxa de queixas - Treino:** {y_train.mean():.2%} | **Val:** {y_val.mean():.2%} | **Teste:** {y_test.mean():.2%}"
-)
+Selecione a questão que deseja visualizar no menu lateral.
+""")
+
+# Sidebar para navegação
+st.sidebar.title("📚 Navegação")
+st.sidebar.markdown("---")
 
-# Pipeline de pré-processamento
-preprocessor = ColumnTransformer(
-    transformers=[
-        ("num", StandardScaler(), numeric_features),
-        (
-            "cat",
-            OneHotEncoder(handle_unknown="ignore", sparse_output=False),
-            categorical_features,
-        ),
-    ],
-    remainder="drop",
+questao_selecionada = st.sidebar.radio(
+    "Selecione a Questão:",
+    options=[1, 2, 3, 4],
+    format_func=lambda x: f"Questão {x}",
+    index=0
 )
 
-# FIX 4: Remove extreme class weights and use balanced approach
-param_grids = {
-    "LogisticRegression": {
-        "classifier__C": [0.01, 0.1, 1.0, 10.0],
-        "classifier__penalty": ["l2"],
-        "classifier__solver": ["lbfgs"],
-        "classifier__class_weight": ["balanced"],  # Only balanced weights
+st.sidebar.markdown("---")
+st.sidebar.markdown("### 📋 Descrição das Questões")
+
+questoes_info = {
+    1: {
+        "titulo": "Regressão Linear - Preços de Imóveis",
+        "pontos": "2,5 pontos",
+        "dataset": "King County House Sales",
+        "tecnica": "Regressão Linear",
+        "descricao": """
+        - Análise Descritiva dos Dados (20%)
+        - Construção do Modelo de Regressão Linear (30%)
+        - Interpretação dos Resultados (10%)
+        - Ajustes no Modelo (30%)
+        - Tomada de Decisão (10%)
+        """
     },
-    "RandomForest": {
-        "classifier__n_estimators": [100, 200],
-        "classifier__max_depth": [6, 8, 10],
-        "classifier__min_samples_split": [10, 20],
-        "classifier__min_samples_leaf": [4, 8],
-        "classifier__class_weight": [
-            "balanced",
-            "balanced_subsample",
-        ],  # Only balanced weights
+    2: {
+        "titulo": "Regressão Logística - Cancelamento de Reservas",
+        "pontos": "2,5 pontos",
+        "dataset": "Hotel Booking Demand",
+        "tecnica": "Regressão Logística",
+        "descricao": """
+        - Análise Descritiva dos Dados (10%)
+        - Modelo de Regressão Logística (60%)
+        - Análise das Features (20%)
+        - Justificativa do Método (10%)
+        """
     },
-    "GradientBoosting": {
-        "classifier__n_estimators": [100, 150],
-        "classifier__learning_rate": [0.05, 0.1],
-        "classifier__max_depth": [3, 4],
-        "classifier__min_samples_split": [10, 20],
-        "classifier__subsample": [0.8, 1.0],
+    3: {
+        "titulo": "ANOVA - Vendas de Varejo Online",
+        "pontos": "2,0 pontos",
+        "dataset": "Online Retail",
+        "tecnica": "ANOVA",
+        "descricao": """
+        - Análise Descritiva dos Dados (10%)
+        - Comparação entre Países (ANOVA) (40%)
+        - Ajustes no Modelo de ANOVA (40%)
+        - Interpretação e Tomada de Decisão (10%)
+        """
     },
+    4: {
+        "titulo": "Risco de Crédito - ML e Clustering",
+        "pontos": "3,0 pontos",
+        "dataset": "Credit Risk",
+        "tecnica": "ML, SHAP, K-Means, DBSCAN",
+        "descricao": """
+        - Discussão sobre o Problema (10%)
+        - Análise Descritiva dos Dados (15%)
+        - Definição e Seleção dos Modelos (30%)
+        - Explicabilidade das Variáveis - SHAP (25%)
+        - Análise Não Supervisionada (15%)
+        - Tomada de Decisão Estratégica (10%)
+        """
+    }
 }
 
-base_models = {
-    "LogisticRegression": LogisticRegression(random_state=random_state, max_iter=2000),
-    "RandomForest": RandomForestClassifier(random_state=random_state, n_jobs=-1),
-    "GradientBoosting": GradientBoostingClassifier(random_state=random_state),
-}
-
-# Testar diferentes estratégias de balanceamento
-sampling_strategies = {
-    "No Sampling": None,
-    "SMOTE": SMOTE(random_state=random_state, k_neighbors=5),
-}
-
-best_models = {}
-results = []
-
-st.subheader("Treinamento e Avaliação dos Modelos")
-
-progress_bar = st.progress(0)
-total_models = len(base_models) * len(sampling_strategies)
-
-for i, (model_name, base_model) in enumerate(base_models.items()):
-    st.write(f"**{model_name}**")
-
-    for j, (sampling_name, sampler) in enumerate(sampling_strategies.items()):
-        if sampler is None:
-            pipeline = Pipeline(
-                [("preprocessor", preprocessor), ("classifier", base_model)]
-            )
-        else:
-            pipeline = ImbPipeline(
-                [
-                    ("preprocessor", preprocessor),
-                    ("sampler", sampler),
-                    ("classifier", base_model),
-                ]
-            )
-
-        # FIX 5: Use nested cross-validation for proper evaluation
-        # Inner CV for hyperparameter tuning
-        inner_cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=random_state)
-
-        grid_search = GridSearchCV(
-            pipeline,
-            param_grids[model_name],
-            cv=inner_cv,
-            scoring="f1",  # F1 balanceia precision e recall
-            n_jobs=-1,
-            verbose=0,
-            error_score="raise",
-        )
-
-        grid_search.fit(X_train, y_train)
-        best_pipeline = grid_search.best_estimator_
-
-        # Outer CV for unbiased evaluation
-        outer_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=random_state)
-        cv_scores = cross_val_score(
-            best_pipeline, X_train, y_train, cv=outer_cv, scoring="f1"
-        )
-
-        # Also evaluate on validation set
-        y_val_pred = best_pipeline.predict(X_val)
-        y_val_proba = best_pipeline.predict_proba(X_val)[:, 1]
-
-        metrics = {
-            "Model": f"{model_name} + {sampling_name}",
-            "Best_Params": str(grid_search.best_params_),
-            "CV_F1_Mean": cv_scores.mean(),
-            "CV_F1_Std": cv_scores.std(),
-            "Val_Accuracy": accuracy_score(y_val, y_val_pred),
-            "Val_Balanced_Acc": balanced_accuracy_score(y_val, y_val_pred),
-            "Val_Precision": precision_score(y_val, y_val_pred, zero_division=0),
-            "Val_Recall": recall_score(y_val, y_val_pred, zero_division=0),
-            "Val_F1": f1_score(y_val, y_val_pred, zero_division=0),
-            "Val_AUC_ROC": roc_auc_score(y_val, y_val_proba),
-            "Val_AUC_PR": average_precision_score(y_val, y_val_proba),
-        }
-
-        results.append(metrics)
-        best_models[f"{model_name} + {sampling_name}"] = best_pipeline
-
-        st.write(
-            f"  {sampling_name:20s} | CV F1: {cv_scores.mean():.4f}±{cv_scores.std():.4f} | Val Recall: {metrics['Val_Recall']:.4f} | Val F1: {metrics['Val_F1']:.4f}"
-        )
-
-        progress_bar.progress((i * len(sampling_strategies) + j + 1) / total_models)
-
-results_df = pd.DataFrame(results).round(4)
-
-# FIX 7: Select best model based on CV scores (unbiased) + validation confirmation
-# Use CV F1 as primary metric, with validation F1 as secondary
-results_df["Score"] = results_df["CV_F1_Mean"] * 0.7 + results_df["Val_F1"] * 0.3
-best_model_name = results_df.loc[results_df["Score"].idxmax(), "Model"]
-
-st.subheader("Melhor Modelo Selecionado")
-st.write(f"**Modelo:** {best_model_name}")
-st.write(
-    f"**CV F1 Score:** {results_df.loc[results_df['Score'].idxmax(), 'CV_F1_Mean']:.4f} ± {results_df.loc[results_df['Score'].idxmax(), 'CV_F1_Std']:.4f}"
-)
-st.write(
-    f"**Val F1 Score:** {results_df.loc[results_df['Score'].idxmax(), 'Val_F1']:.4f}"
-)
-
-st.subheader("Top 5 Modelos (ordenados por Score combinado)")
-top_models = results_df.nlargest(5, "Score")[
-    ["Model", "CV_F1_Mean", "CV_F1_Std", "Val_F1", "Val_Recall", "Score"]
-]
-st.dataframe(top_models, use_container_width=True)
-
-# FIX 8: Proper threshold tuning without data leakage
-best_pipeline = best_models[best_model_name]
-y_val_proba = best_pipeline.predict_proba(X_val)[:, 1]
-
-st.subheader("Threshold Tuning")
-st.write("**Diagnóstico de Probabilidades no Validation Set:**")
-st.write(f"- Min: {y_val_proba.min():.4f} | Max: {y_val_proba.max():.4f}")
-st.write(f"- Mean: {y_val_proba.mean():.4f} | Median: {np.median(y_val_proba):.4f}")
-st.write(
-    f"- P95: {np.percentile(y_val_proba, 95):.4f} | P99: {np.percentile(y_val_proba, 99):.4f}"
-)
-st.write(
-    f"- Positivos reais no val: {y_val.sum()} de {len(y_val)} ({y_val.mean():.2%})"
-)
-
-# Enhanced probability distribution visualization
-fig_prob = go.Figure()
-
-# Histogram for each class
-for class_label in [0, 1]:
-    mask = y_val == class_label
-    fig_prob.add_trace(
-        go.Histogram(
-            x=y_val_proba[mask], name=f"Classe {class_label}", opacity=0.7, nbinsx=30
-        )
-    )
-
-fig_prob.update_layout(
-    title="Distribuição de Probabilidades por Classe",
-    xaxis_title="Probabilidade Predita",
-    yaxis_title="Frequência",
-    barmode="overlay",
-)
-st.plotly_chart(fig_prob, use_container_width=True)
-
-# FIX 9: Threshold tuning using validation set only (no test set leakage)
-precision, recall, thresholds = precision_recall_curve(y_val, y_val_proba)
-f1_scores = 2 * (precision * recall) / (precision + recall + 1e-10)
-best_threshold_idx = np.argmax(f1_scores)
-best_threshold = (
-    thresholds[best_threshold_idx] if best_threshold_idx < len(thresholds) else 0.5
-)
-
-st.write("**Threshold Tuning (apenas no conjunto de VALIDAÇÃO):**")
-st.write(f"- Threshold ótimo: {best_threshold:.4f}")
-st.write(f"- F1 esperado no threshold: {f1_scores[best_threshold_idx]:.4f}")
-st.write(f"- Precision no threshold: {precision[best_threshold_idx]:.4f}")
-st.write(f"- Recall no threshold: {recall[best_threshold_idx]:.4f}")
-
-# Final evaluation on test set
-y_test_proba = best_pipeline.predict_proba(X_test)[:, 1]
-y_test_pred_default = best_pipeline.predict(X_test)
-y_test_pred_tuned = (y_test_proba >= best_threshold).astype(int)
-
-st.subheader("Resultados Finais no Conjunto de Teste")
-
-col1, col2 = st.columns(2)
-
-with col1:
-    st.write("**Threshold Padrão (0.5):**")
-    st.write(f"- Recall: {recall_score(y_test, y_test_pred_default):.4f}")
-    st.write(
-        f"- Precision: {precision_score(y_test, y_test_pred_default, zero_division=0):.4f}"
-    )
-    st.write(f"- F1-Score: {f1_score(y_test, y_test_pred_default):.4f}")
-    st.write(
-        f"- Balanced Accuracy: {balanced_accuracy_score(y_test, y_test_pred_default):.4f}"
-    )
-
-with col2:
-    st.write(f"**Threshold Otimizado ({best_threshold:.4f}):**")
-    st.write(f"- Recall: {recall_score(y_test, y_test_pred_tuned):.4f}")
-    st.write(
-        f"- Precision: {precision_score(y_test, y_test_pred_tuned, zero_division=0):.4f}"
-    )
-    st.write(f"- F1-Score: {f1_score(y_test, y_test_pred_tuned):.4f}")
-    st.write(
-        f"- Balanced Accuracy: {balanced_accuracy_score(y_test, y_test_pred_tuned):.4f}"
-    )
-    st.write(f"- AUC-ROC: {roc_auc_score(y_test, y_test_proba):.4f}")
-    st.write(f"- AUC-PR: {average_precision_score(y_test, y_test_proba):.4f}")
-
-# Enhanced ROC Curve
-fpr, tpr, _ = roc_curve(y_test, y_test_proba)
-roc_auc = auc(fpr, tpr)
-
-fig_roc = go.Figure()
-fig_roc.add_trace(
-    go.Scatter(
-        x=fpr,
-        y=tpr,
-        mode="lines",
-        name=f"ROC Curve (AUC = {roc_auc:.3f})",
-        line=dict(color="blue", width=3),
-    )
-)
-fig_roc.add_trace(
-    go.Scatter(
-        x=[0, 1],
-        y=[0, 1],
-        mode="lines",
-        name="Random Classifier",
-        line=dict(color="red", dash="dash"),
-    )
-)
-
-fig_roc.update_layout(
-    title="Curva ROC - Avaliação do Modelo",
-    xaxis_title="Taxa de Falsos Positivos",
-    yaxis_title="Taxa de Verdadeiros Positivos",
-    width=600,
-    height=500,
-)
-st.plotly_chart(fig_roc, use_container_width=True)
-
-# Enhanced confusion matrix heatmap
-cm = confusion_matrix(y_test, y_test_pred_tuned)
-st.write("**Matriz de Confusão:**")
-st.write("           Pred 0  Pred 1")
-st.write(f"Real 0     {cm[0, 0]:6d}  {cm[0, 1]:6d}")
-st.write(f"Real 1     {cm[1, 0]:6d}  {cm[1, 1]:6d}")
-
-fig_cm = px.imshow(
-    cm,
-    text_auto=True,
-    aspect="auto",
-    title="Matriz de Confusão - Threshold Otimizado",
-    labels=dict(x="Predito", y="Real", color="Contagem"),
-    color_continuous_scale="Blues",
-)
-fig_cm.update_layout(xaxis_title="Predito", yaxis_title="Real", width=500, height=400)
-st.plotly_chart(fig_cm, use_container_width=True)
-
-# Feature importance
-preprocessor_fitted = best_pipeline.named_steps["preprocessor"]
-classifier = best_pipeline.named_steps["classifier"]
-
-feature_names = numeric_features + list(
-    preprocessor_fitted.named_transformers_["cat"].get_feature_names_out(
-        categorical_features
-    )
-)
-
-if hasattr(classifier, "feature_importances_"):
-    importances = classifier.feature_importances_
-elif hasattr(classifier, "coef_"):
-    importances = np.abs(classifier.coef_[0])
+info = questoes_info[questao_selecionada]
+st.sidebar.markdown(f"""
+**{info['titulo']}**
+
+- **Pontos:** {info['pontos']}
+- **Dataset:** {info['dataset']}
+- **Técnica:** {info['tecnica']}
+""")
+st.sidebar.markdown(info['descricao'])
+
+# Carregar e executar o streamlit app da questão selecionada
+base_path = Path(__file__).parent.parent
+questao_dir = base_path / f"questao-{questao_selecionada}"
+streamlit_file = questao_dir / "src" / "streamlit_app.py"
+
+if streamlit_file.exists():
+    st.markdown(f"## Questão {questao_selecionada} - {info['titulo']}")
+    st.markdown("---")
+
+    # Mudar para o diretório da questão e executar
+    original_cwd = os.getcwd()
+    os.chdir(str(questao_dir))
+
+    try:
+        # Ler o código do streamlit app
+        with open(streamlit_file, 'r', encoding='utf-8') as f:
+            code = f.read()
+
+        # Processar o código para remover configurações duplicadas
+        lines = code.split('\n')
+        exec_lines = []
+        skip_section = False
+
+        for line in lines:
+            # Pular st.set_page_config
+            if 'st.set_page_config' in line:
+                skip_section = True
+                continue
+            if skip_section and (line.strip() == '' or line.startswith('st.markdown')):
+                if '"""' in line or "'''" in line:
+                    # Encontrar fim do markdown
+                    if line.count('"""') == 2 or line.count("'''") == 2:
+                        skip_section = False
+                continue
+            if skip_section:
+                continue
+
+            # Pular markdown inicial duplicado (primeiras 10 linhas)
+            if len(exec_lines) < 5 and ('Questão' in line or 'Regressão' in line or 'ANOVA' in line or 'Risco' in line):
+                if '#' in line:
+                    continue
+
+            exec_lines.append(line)
+
+        exec_code = '\n'.join(exec_lines)
+
+        # Criar namespace com imports
+        exec_globals = {'st': st, '__file__': str(streamlit_file)}
+
+        # Imports comuns
+        import warnings
+        import numpy as np
+        import pandas as pd
+        import plotly.express as px
+        import plotly.graph_objects as go
+
+        exec_globals.update({
+            'warnings': warnings,
+            'np': np,
+            'pd': pd,
+            'px': px,
+            'go': go,
+        })
+
+        # Imports específicos por questão
+        if questao_selecionada == 1:
+            from sklearn.linear_model import LinearRegression
+            from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+            from sklearn.model_selection import train_test_split
+            from scipy import stats
+            from statsmodels.stats.diagnostic import het_breuschpagan
+            from statsmodels.stats.stattools import durbin_watson
+            from statsmodels.stats.outliers_influence import variance_inflation_factor
+            import statsmodels.api as sm
+            exec_globals.update(locals())
+        elif questao_selecionada == 2:
+            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, classification_report)
+            from sklearn.model_selection import train_test_split
+            from sklearn.preprocessing import StandardScaler, LabelEncoder
+            from imblearn.over_sampling import SMOTE
+            exec_globals.update(locals())
+        elif questao_selecionada == 3:
+            from scipy import stats
+            import statsmodels.formula.api as smf
+            from statsmodels.stats.anova import anova_lm
+            from statsmodels.stats.stattools import durbin_watson
+            from statsmodels.stats.oneway import anova_oneway
+            exec_globals.update(locals())
+        elif questao_selecionada == 4:
+            from sklearn.linear_model import LogisticRegression
+            from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+            from sklearn.tree import DecisionTreeClassifier
+            from sklearn.svm import SVC
+            from xgboost import XGBClassifier
+            from sklearn.metrics import (accuracy_score, precision_score, recall_score, f1_score,
+                                       roc_auc_score, roc_curve, confusion_matrix)
+            from sklearn.model_selection import train_test_split
+            from sklearn.preprocessing import StandardScaler, LabelEncoder
+            from sklearn.cluster import KMeans, DBSCAN
+            from imblearn.over_sampling import SMOTE
+            try:
+                import shap
+                exec_globals['shap'] = shap
+            except:
+                pass
+            exec_globals.update(locals())
+
+        # Executar o código
+        exec(exec_code, exec_globals)
+
+    except Exception as e:
+        st.error(f"Erro ao executar questão {questao_selecionada}: {str(e)}")
+        import traceback
+        with st.expander("Detalhes do erro"):
+            st.code(traceback.format_exc())
+        st.info(f"""
+        **Para executar esta questão diretamente:**
+
+        ```bash
+        cd questao-{questao_selecionada}
+        streamlit run src/streamlit_app.py
+        ```
+        """)
+    finally:
+        os.chdir(original_cwd)
 else:
-    importances = None
-
-if importances is not None:
-    # Get top 15 features
-    top_features = pd.DataFrame(
-        {"feature": feature_names, "importance": importances}
-    ).nlargest(15, "importance")
-
-    st.subheader("Top 15 Features Mais Importantes")
-    st.dataframe(top_features, use_container_width=True)
-
-    # Enhanced feature importance visualization
-    fig_importance = px.bar(
-        top_features,
-        x="importance",
-        y="feature",
-        orientation="h",
-        title=f"Feature Importance - {best_model_name}",
-        color="importance",
-        color_continuous_scale="viridis",
-    )
-    fig_importance.update_layout(
-        xaxis_title="Importância",
-        yaxis_title="Features",
-        height=600,
-        coloraxis_showscale=False,
-    )
-    st.plotly_chart(fig_importance, use_container_width=True)
+    st.error(f"Arquivo não encontrado: {streamlit_file}")
+    st.info(f"""
+    **Para executar esta questão diretamente:**
+
+    ```bash
+    cd questao-{questao_selecionada}
+    streamlit run src/streamlit_app.py
+    ```
+    """)
 
 st.markdown("---")
-st.caption("PPCA/UnB | Outubro 2025")
+st.caption("PPCA/UnB | Novembro 2025")