Upload 3 files

app.py

@@ -0,0 +1,238 @@
+# Requisitos:
+# pip install streamlit pandas numpy scipy statsmodels scikit-posthocs matplotlib seaborn
+
+import warnings
+warnings.filterwarnings("ignore")
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from scipy import stats
+import statsmodels.api as sm
+from statsmodels.formula.api import ols
+from statsmodels.stats.multicomp import pairwise_tukeyhsd
+from statsmodels.stats.oneway import anova_oneway # Necessário para Welch ANOVA
+
+import scikit_posthocs as sp # Necessário para Dunn Post-hoc
+
+# 1. Configuração da Página e Título
+st.set_page_config(layout="wide") 
+st.title("🏡 Análise Comparativa de Preços de Imóveis (Ames Housing)")
+st.markdown("""
+    Dashboard interativo para explorar a relação entre variáveis categóricas
+    (Bairro, Qualidade, Lareiras) e o **SalePrice** (Preço de Venda)
+    usando Análise de Variância (ANOVA) e testes não-paramétricos.
+""")
+
+# 2. Definição das Colunas/Caminhos
+Y_COL = "SalePrice"
+CAT_COLS = ["Neighborhood", "OverallQual", "Fireplaces"]
+# ATENÇÃO: Substitua o caminho abaixo pelo caminho correto do seu arquivo CSV
+DATA_PATH = r"C:\Users\felip\Downloads\AmesHousing.csv.csv"
+
+# -----------------------------------------------------------
+# 1) Carregar e Pré-processar Dataset com Caching
+# -----------------------------------------------------------
+@st.cache_data # Crucial para performance!
+def load_and_preprocess_data(file_path, y_col, cat_cols):
+    """Carrega, pré-processa e retorna o DataFrame."""
+    try:
+        df = pd.read_csv(file_path, low_memory=False)
+    except FileNotFoundError:
+        st.error(f"Erro: Arquivo não encontrado no caminho: {file_path}")
+        return pd.DataFrame()
+
+    # Seu código original de pré-processamento
+    if "Id" in df.columns:
+        df = df.drop(columns=["Id"])
+    
+    # Verifica a existência das colunas
+    missing_cols = [c for c in [y_col] + cat_cols if c not in df.columns]
+    if missing_cols:
+        st.error(f"Colunas esperadas não encontradas no CSV: {', '.join(missing_cols)}")
+        return pd.DataFrame()
+
+    # Seleção de colunas, remoção de NA e conversão de tipos
+    df = df[[y_col] + cat_cols].copy()
+    df = df.dropna(subset=[y_col] + cat_cols)
+    df["Neighborhood"] = df["Neighborhood"].astype(str)
+    df["Fireplaces"] = df["Fireplaces"].astype(str) 
+    df["OverallQual"] = df["OverallQual"].astype(str) # Tratar como string para ANOVA
+
+    return df
+
+# --- Chamada da função de carregamento ---
+df = load_and_preprocess_data(DATA_PATH, Y_COL, CAT_COLS)
+
+if df.empty:
+    st.stop() 
+
+# -----------------------------------------------------------
+# 3) Funções auxiliares de teste (Mantidas)
+# -----------------------------------------------------------
+
+def check_normality_by_group(data, group_col, value_col, alpha=0.05):
+    """Shapiro-Wilk por grupo; retorna DataFrame com p-values e decisão"""
+    results = []
+    groups = data[group_col].unique()
+    for g in sorted(groups):
+        vals = data.loc[data[group_col]==g, value_col].values
+        # Shapiro requer n between 3 and 5000
+        if len(vals) < 3:
+            p = np.nan
+            stat = np.nan
+            decision = "n<3"
+        else:
+            if len(vals) > 5000:
+                vals_sample = np.random.choice(vals, 5000, replace=False)
+            else:
+                vals_sample = vals
+            stat, p = stats.shapiro(vals_sample)
+            decision = "normal" if p > alpha else "not_normal"
+        results.append({"group": g, "n": len(vals), "shapiro_stat": stat, "shapiro_p": p, "decision": decision})
+    return pd.DataFrame(results)
+
+def levene_test(data, group_col, value_col):
+    """Levene test para homocedasticidade."""
+    groups = [data.loc[data[group_col]==g, value_col].values for g in data[group_col].unique()]
+    stat, p = stats.levene(*groups, center='median') 
+    return stat, p
+
+def anderson_darling_overall(data, value_col):
+    """Anderson-Darling test para normalidade global."""
+    res = stats.anderson(data[value_col].values, dist='norm')
+    return res
+
+# ------------------------------------------------------------------
+# 4. Lógica Principal: Interatividade e Análise
+# ------------------------------------------------------------------
+
+# 4.1. Seletor de Variável na Sidebar (Interatividade)
+st.sidebar.header("Variável a Analisar")
+
+selected_cat = st.sidebar.selectbox(
+    "Selecione a Variável Categórica:",
+    options=CAT_COLS,
+    help="Escolha qual variável de agrupamento será analisada em relação ao SalePrice."
+)
+
+# Definir as variáveis para a análise (substitui o loop for)
+cat = selected_cat
+y_col = Y_COL
+
+st.header(f"Análise: {cat} vs {y_col}")
+st.markdown("---")
+
+
+# Boxplot
+st.subheader("1. Visualização: Boxplot")
+st.markdown(f"Distribuição de `{y_col}` por categoria em `{cat}` (ordenado pela mediana).")
+
+# Garante que o gráfico seja desenhado em uma nova figura para o Streamlit
+fig, ax = plt.subplots(figsize=(10, 6)) 
+order = df.groupby(cat)[y_col].median().sort_values(ascending=False).index
+sns.boxplot(x=cat, y=y_col, data=df, order=order, ax=ax)
+ax.set_title(f"{y_col} por {cat}")
+plt.xticks(rotation=45)
+plt.tight_layout()
+
+st.pyplot(fig) # Comando Streamlit para exibir o gráfico
+
+# Testes de pressupostos
+st.subheader("2. Testes de Pressupostos (Homogeneidade e Normalidade)")
+
+# Normalidade
+st.markdown("##### Teste de Normalidade (Shapiro-Wilk) por Grupo")
+sh = check_normality_by_group(df, cat, y_col)
+st.dataframe(sh.head(20), use_container_width=True)
+
+# Anderson-Darling (Global)
+ad = anderson_darling_overall(df, y_col)
+st.info(f"**Anderson-Darling (Global):** stat={ad.statistic:.4f}. Valores críticos: {ad.critical_values} (Níveis de Significância: {ad.significance_level}%)")
+
+# Homocedasticidade (Levene)
+st.markdown("##### Teste de Homocedasticidade (Levene)")
+stat_levene, p_levene = levene_test(df, cat, y_col)
+st.write(f"**Levene test (center=median):** Estatística={stat_levene:.4f}, p-valor={p_levene:.4f}")
+
+# --------------------------------------------------------------------
+# 3. Análise Estatística (ANOVA / Welch / Kruskal)
+# --------------------------------------------------------------------
+
+st.subheader("3. Análise Estatística e Post-Hoc")
+
+# ANOVA clássica (one-way)
+try:
+    model = ols(f"{y_col} ~ C({cat})", data=df).fit()
+    anova_table = sm.stats.anova_lm(model, typ=2)
+    st.markdown("##### ANOVA (Type II) results:")
+    st.dataframe(anova_table)
+
+    anova_p = anova_table.loc[f"C({cat})", "PR(>F)"] if f"C({cat})" in anova_table.index else anova_table.iloc[0,3]
+except Exception as e:
+    st.error(f"Erro ao rodar ANOVA clássica: {e}")
+    anova_p = 1.0 # Define um p-valor alto para não rodar o Tukey
+
+
+# Lógica de Testes Robustos / Não-Paramétricos
+non_normal_groups = sh[sh["decision"]=="not_normal"]
+prop_non_normal = len(non_normal_groups) / len(sh)
+
+col1, col2 = st.columns(2)
+
+with col1:
+    # Teste de Homocedasticidade
+    if p_levene < 0.05:
+        st.warning("⚠️ **Alerta:** Levene $p < 0.05$ (Variâncias Heterogêneas). Aplicando **Welch ANOVA**.")
+        try:
+            welch_res = anova_oneway(df[y_col], df[cat], use_var='unequal')
+            st.code(f"Welch ANOVA: F={welch_res.fvalue:.4f}, p={welch_res.pvalue:.4f}")
+        except Exception as e:
+            st.error(f"Erro ao rodar anova_oneway: {e}")
+    else:
+        st.success("✅ **Pressuposto OK:** Variâncias homogêneas (Levene $p \ge 0.05$).")
+
+with col2:
+    # Teste de Normalidade / Kruskal-Wallis
+    if prop_non_normal > 0.3:
+        st.warning(f"⚠️ **Alerta:** {prop_non_normal:.0%} dos grupos rejeitam normalidade. Aplicando **Kruskal-Wallis** (Teste não-paramétrico).")
+        groups = [df.loc[df[cat]==g, y_col].values for g in df[cat].unique()]
+        try:
+            kw_stat, kw_p = stats.kruskal(*groups)
+            st.code(f"Kruskal-Wallis: Stat={kw_stat:.4f}, p={kw_p:.6f}")
+            if kw_p < 0.05:
+                st.info("Kruskal-Wallis indica diferença significativa.")
+                
+                # Post-hoc Dunn
+                st.markdown("###### Post-hoc Dunn (Bonferroni)")
+                dunn = sp.posthoc_dunn(df, val_col=y_col, group_col=cat, p_adjust='bonferroni')
+                st.dataframe(dunn, use_container_width=True)
+        except Exception as e:
+            st.error(f"Erro ao rodar Kruskal-Wallis: {e}")
+    else:
+        st.success(f"✅ **Pressuposto OK:** Baixa rejeição de normalidade ({prop_non_normal:.0%}).")
+        
+        # Teste Post-hoc Tukey (se ANOVA clássica for significativa)
+        if anova_p < 0.05:
+            st.markdown("##### Post-hoc Tukey HSD (Se ANOVA Signif.)")
+            st.info("ANOVA clássica indica diferenças. Aplicando Tukey HSD.")
+            tukey = pairwise_tukeyhsd(endog=df[y_col], groups=df[cat], alpha=0.05)
+            st.text(tukey.summary()) # st.text é melhor para summaries de modelos
+        else:
+            st.info("ANOVA NÃO indicou diferenças estatisticamente significativas entre categorias.")
+
+
+# --------------------------------------------------------------------
+# 4. Resumo Final
+# --------------------------------------------------------------------
+
+st.subheader("4. Resumo por Categoria")
+st.markdown("Medidas descritivas do preço de venda agrupadas pela categoria selecionada, ordenadas pela média.")
+summary = df.groupby(cat)[y_col].agg(['count','mean','median','std']).sort_values('mean', ascending=False)
+st.dataframe(summary, use_container_width=True)
+
+st.markdown("---")
+st.success("Análise concluída. Utilize o seletor na barra lateral para trocar de variável.")

requirements.txt

@@ -1,3 +1,8 @@
-altair
-pandas
-streamlit
+streamlit
+pandas
+numpy
+scipy
+statsmodels
+scikit-posthocs
+matplotlib
+seaborn