dashboard_anova.py

README.md

@@ -0,0 +1,292 @@
+---
+license: mit
+tags:
+- code
+---
+# streamlit_dashboard_anova.py
+import streamlit as st
+import pandas as pd
+import statsmodels.api as sm
+from statsmodels.formula.api import ols
+from scipy.stats import shapiro, levene, kruskal, anderson
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np  # Adicionado para lidar com potenciais issues numéricas
+
+
+# --- Funções de Análise (Adaptadas do script anterior) ---
+
+@st.cache_data  # Cache para otimizar o carregamento de dados
+def load_data():
+    """Carrega o Ames Housing Dataset de uma URL e faz uma limpeza básica."""
+    urls_tentativas = [
+        "https://raw.githubusercontent.com/Viniciusalgueiro/Ameshousing/refs/heads/main/AmesHousing.csv"
+    ]
+    df = None
+    url_carregada = ""
+    for url in urls_tentativas:
+        try:
+            df = pd.read_csv(url)
+            url_carregada = url
+            break
+        except Exception:
+            continue  # Tenta a próxima URL
+
+    if df is None:
+        st.error("Não foi possível carregar o dataset de nenhuma das URLs conhecidas.")
+        return None, None, [], []
+
+    st.success(f"Dataset carregado com sucesso de: {url_carregada}")
+    df.columns = df.columns.str.replace('[^A-Za-z0-9_]+', '', regex=True).str.lower()
+
+    coluna_preco_nome = None
+    if 'saleprice' in df.columns:
+        coluna_preco_nome = 'saleprice'
+    elif 'sale_price' in df.columns:
+        df.rename(columns={'sale_price': 'saleprice'}, inplace=True)
+        coluna_preco_nome = 'saleprice'
+    # Adicionar mais heurísticas se necessário
+
+    if coluna_preco_nome:
+        df[coluna_preco_nome] = pd.to_numeric(df[coluna_preco_nome], errors='coerce')
+        df.dropna(subset=[coluna_preco_nome], inplace=True)
+
+    colunas_categoricas_potenciais = df.select_dtypes(include=['object']).columns.tolist()
+    colunas_numericas_discretas = [col for col in df.select_dtypes(include=np.number).columns
+                                   if df[col].nunique() < 20 and col != coluna_preco_nome]  # Exemplo de heurística
+    colunas_categoricas_potenciais.extend(colunas_numericas_discretas)
+
+    # Remover duplicatas e garantir que a coluna de preço não está na lista
+    colunas_categoricas_potenciais = sorted(
+        list(set(col for col in colunas_categoricas_potenciais if col != coluna_preco_nome)))
+
+    return df, coluna_preco_nome, colunas_categoricas_potenciais, df.columns.tolist()
+
+
+def perform_anova_for_variable(df_analysis, var_cat, col_preco):
+    """Executa ANOVA e testes de pressupostos para uma variável."""
+    results = {"var_cat": var_cat, "plots": {}}
+
+    df_var = df_analysis[[var_cat, col_preco]].copy()
+
+    # Converter para categoria se não for e garantir que tem pelo menos 2 níveis
+    if df_var[var_cat].dtype != 'object' and not pd.api.types.is_categorical_dtype(df_var[var_cat]):
+        df_var[var_cat] = df_var[var_cat].astype('category')
+
+    df_var.dropna(inplace=True)  # Remove NaNs especificamente para este par
+
+    if df_var[var_cat].nunique() < 2 or len(df_var) < 10:  # Mínimo de observações e níveis
+        results["error"] = "Dados insuficientes ou poucos níveis para análise após limpeza."
+        return results
+
+    formula = f'{col_preco} ~ C({var_cat})'
+    try:
+        modelo = ols(formula, data=df_var).fit()
+        results["anova_table"] = sm.stats.anova_lm(modelo, typ=2)
+
+        p_valor_anova = None
+        if f'C({var_cat})' in results["anova_table"].index:
+            p_valor_anova = results["anova_table"].loc[f'C({var_cat})', 'PR(>F)']
+        elif not results["anova_table"].empty:
+            p_valor_anova = results["anova_table"]['PR(>F)'].iloc[0]
+        results["p_valor_anova"] = p_valor_anova
+
+        residuos = modelo.resid
+        results["residuos_count"] = len(residuos)
+
+        # 1. Normalidade dos resíduos
+        normalidade_ok = False
+        if len(residuos) >= 3:
+            if len(residuos) <= 5000:
+                stat_shapiro, p_shapiro = shapiro(residuos)
+                results["shapiro_test"] = (stat_shapiro, p_shapiro)
+                if p_shapiro >= 0.05: normalidade_ok = True
+            else:
+                ad_result = anderson(residuos)
+                results["anderson_test"] = ad_result
+                # Verifica se a estatística é menor que o valor crítico para 5%
+                sig_level_idx = ad_result.significance_level.tolist().index(5.0)
+                if ad_result.statistic < ad_result.critical_values[sig_level_idx]:
+                    normalidade_ok = True
+        results["normalidade_ok"] = normalidade_ok
+
+        # Plots de Normalidade
+        fig_norm, ax_norm = plt.subplots(1, 2, figsize=(10, 4))
+        if len(residuos) > 1:
+            sns.histplot(residuos, kde=True, ax=ax_norm[0], stat="density", bins=30)
+            ax_norm[0].set_title(f'Histograma Resíduos ({var_cat})', fontsize=10)
+            sm.qqplot(residuos, line='s', ax=ax_norm[1], markerfacecolor="skyblue", markeredgecolor="dodgerblue",
+                      alpha=0.7)
+            ax_norm[1].set_title(f'Q-Q Plot Resíduos ({var_cat})', fontsize=10)
+        else:
+            ax_norm[0].text(0.5, 0.5, "Poucos dados", ha='center', va='center')
+            ax_norm[1].text(0.5, 0.5, "Poucos dados", ha='center', va='center')
+        plt.tight_layout()
+        results["plots"]["normalidade"] = fig_norm
+
+        # 2. Homocedasticidade (Teste de Levene)
+        homocedasticidade_ok = False
+        grupos = [df_var[col_preco][df_var[var_cat] == categoria].dropna() for categoria in df_var[var_cat].unique()]
+        grupos_validos = [g for g in grupos if len(g) >= 2]  # Levene precisa de grupos com pelo menos 2 obs
+        if len(grupos_validos) >= 2:
+            stat_levene, p_levene = levene(*grupos_validos)
+            results["levene_test"] = (stat_levene, p_levene)
+            if p_levene >= 0.05: homocedasticidade_ok = True
+        results["homocedasticidade_ok"] = homocedasticidade_ok
+
+        # 3. Kruskal-Wallis (se necessário)
+        if not normalidade_ok or not homocedasticidade_ok:
+            if len(grupos_validos) >= 2:
+                stat_kruskal, p_kruskal = kruskal(*grupos_validos)
+                results["kruskal_test"] = (stat_kruskal, p_kruskal)
+
+        # Boxplot
+        fig_box, ax_box = plt.subplots(figsize=(10, 5))
+        unique_cats = df_var[var_cat].nunique()
+        order_boxplot = None
+        if unique_cats > 5 and unique_cats < 50:  # Evitar ordenar muitas categorias
+            try:
+                order_boxplot = df_var.groupby(var_cat)[col_preco].median().sort_values().index
+            except Exception:
+                order_boxplot = df_var[var_cat].unique()  # Fallback
+
+        sns.boxplot(x=var_cat, y=col_preco, data=df_var, order=order_boxplot, ax=ax_box, palette="viridis")
+        ax_box.set_title(f'Distribuição de {col_preco} por {var_cat}', fontsize=12)
+        if unique_cats > 10:
+            plt.setp(ax_box.get_xticklabels(), rotation=45, ha='right', fontsize=8)
+        else:
+            plt.setp(ax_box.get_xticklabels(), fontsize=9)
+
+        plt.tight_layout()
+        results["plots"]["boxplot"] = fig_box
+
+    except Exception as e:
+        results["error"] = str(e)
+    return results
+
+
+# --- Interface do Streamlit ---
+st.set_page_config(layout="wide", page_title="Dashboard de Análise Imobiliária ANOVA")
+
+st.title("🏠 Dashboard de Análise Imobiliária com ANOVA")
+st.markdown("""
+Esta ferramenta interativa permite realizar Análises de Variância (ANOVA) no Ames Housing Dataset
+para investigar como diferentes características categóricas impactam o preço de venda dos imóveis.
+""")
+
+# Carregar Dados
+df, coluna_preco, colunas_categoricas_selecionaveis, todas_colunas = load_data()
+
+if df is not None and coluna_preco is not None:
+    st.header("1. Visão Geral dos Dados")
+    if st.checkbox("Mostrar amostra dos dados"):
+        st.dataframe(df.head())
+    st.write(f"Total de registros carregados (após limpeza inicial na coluna '{coluna_preco}'): {len(df)}")
+    st.write(f"Coluna alvo (preço): `{coluna_preco}`")
+
+    st.sidebar.header("⚙️ Configurações da Análise")
+    # Seleção de variáveis
+    variaveis_selecionadas = st.sidebar.multiselect(
+        "Escolha 1 a 3 variáveis categóricas para análise ANOVA:",
+        options=colunas_categoricas_selecionaveis,
+        max_selections=3
+    )
+
+    if variaveis_selecionadas:
+        st.header("2. Resultados da Análise ANOVA")
+        st.markdown(f"Analisando o impacto de **{', '.join(variaveis_selecionadas)}** sobre **{coluna_preco}**.")
+
+        for var_analisada in variaveis_selecionadas:
+            st.subheader(f"Análise para: `{var_analisada}`")
+
+            # Prepara dados específicos para a variável (remove NaNs apenas para as colunas envolvidas)
+            df_analise_var = df[[var_analisada, coluna_preco]].copy()
+            df_analise_var.dropna(subset=[var_analisada, coluna_preco], inplace=True)
+
+            if df_analise_var.empty or df_analise_var[var_analisada].nunique() < 2:
+                st.warning(f"Não há dados suficientes ou níveis para '{var_analisada}' após limpeza. Pulando.")
+                continue
+
+            resultados_var = perform_anova_for_variable(df_analise_var, var_analisada, coluna_preco)
+
+            if "error" in resultados_var:
+                st.error(f"Erro ao analisar '{var_analisada}': {resultados_var['error']}")
+                continue
+
+            # Exibir Tabela ANOVA
+            if "anova_table" in resultados_var:
+                st.markdown("**Tabela ANOVA:**")
+                st.dataframe(resultados_var["anova_table"])
+                p_anova = resultados_var.get("p_valor_anova")
+                if p_anova is not None:
+                    if p_anova < 0.05:
+                        st.success(
+                            f"✅ ANOVA: Há uma diferença estatisticamente significativa nos preços (p-valor: {p_anova:.4e}).")
+                    else:
+                        st.info(
+                            f"ℹ️ ANOVA: Não há uma diferença estatisticamente significativa nos preços (p-valor: {p_anova:.4e}).")
+
+            # Pressupostos e Testes Alternativos
+            with st.expander("Verificar Pressupostos da ANOVA e Testes Alternativos"):
+                st.markdown("**Normalidade dos Resíduos:**")
+                if "shapiro_test" in resultados_var:
+                    stat, p_val = resultados_var["shapiro_test"]
+                    st.write(f"Shapiro-Wilk: Estatística={stat:.4f}, P-valor={p_val:.4e}")
+                elif "anderson_test" in resultados_var:
+                    ad_res = resultados_var["anderson_test"]
+                    st.write(f"Anderson-Darling: Estatística={ad_res.statistic:.4f}")
+                    # st.write(f"  Valores Críticos: {ad_res.critical_values}")
+                    # st.write(f"  Níveis de Significância: {ad_res.significance_level}")
+
+                if resultados_var.get("normalidade_ok"):
+                    st.success("✅ Resíduos parecem ser normalmente distribuídos.")
+                else:
+                    st.warning("⚠️ Resíduos NÃO parecem ser normalmente distribuídos.")
+
+                if "normalidade" in resultados_var["plots"]:
+                    st.pyplot(resultados_var["plots"]["normalidade"])
+
+                st.markdown("**Homogeneidade das Variâncias (Homocedasticidade):**")
+                if "levene_test" in resultados_var:
+                    stat_l, p_l = resultados_var["levene_test"]
+                    st.write(f"Teste de Levene: Estatística={stat_l:.4f}, P-valor={p_l:.4e}")
+                    if resultados_var.get("homocedasticidade_ok"):
+                        st.success("✅ Variâncias parecem ser homogêneas.")
+                    else:
+                        st.warning("⚠️ Variâncias NÃO parecem ser homogêneas.")
+                else:
+                    st.write("Teste de Levene não pôde ser realizado (dados insuficientes).")
+
+                if "kruskal_test" in resultados_var:
+                    st.markdown("**Teste de Kruskal-Wallis (Alternativa Não Paramétrica):**")
+                    stat_k, p_k = resultados_var["kruskal_test"]
+                    st.write(f"Kruskal-Wallis: Estatística={stat_k:.4f}, P-valor={p_k:.4e}")
+                    if p_k < 0.05:
+                        st.success(f"✅ Kruskal-Wallis: Diferença significativa nas medianas dos preços.")
+                    else:
+                        st.info(f"ℹ️ Kruskal-Wallis: Sem diferença significativa nas medianas dos preços.")
+
+            # Boxplot
+            if "boxplot" in resultados_var["plots"]:
+                st.markdown("**Distribuição de Preços por Categoria:**")
+                st.pyplot(resultados_var["plots"]["boxplot"])
+
+            st.markdown("---")  # Separador entre variáveis
+
+    elif not variaveis_selecionadas and st.sidebar.button("Analisar", type="primary",
+                                                          help="Clique para iniciar após selecionar as variáveis.",
+                                                          use_container_width=True, disabled=True):
+        # Botão fica desabilitado até selecionar algo, apenas para feedback visual
+        pass
+
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("Desenvolvido como parte de uma análise de dados imobiliários.")
+
+elif df is None and coluna_preco is None:  # Falha no carregamento
+    st.warning("Aguardando carregamento dos dados ou verifique os erros acima.")
+else:  # Carregou mas não achou coluna de preço ou não há categóricas
+    if coluna_preco is None:
+        st.error(
+            f"A coluna de preço de venda ('saleprice' ou similar) não foi encontrada no dataset. Verifique as colunas disponíveis: {todas_colunas}")
+    if not colunas_categoricas_selecionaveis:
+        st.error("Nenhuma coluna categórica adequada para análise foi identificada.")