Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,19 +1,24 @@
-# streamlit_dashboard_anova.py
+# streamlit_dashboard_unificado.py
+
 import streamlit as st
 import pandas as pd
+import numpy as np
 import statsmodels.api as sm
 from statsmodels.formula.api import ols
 from scipy.stats import shapiro, levene, kruskal, anderson
+from statsmodels.stats.outliers_influence import variance_inflation_factor
+from sklearn.metrics import mean_squared_error, mean_absolute_error
 import matplotlib.pyplot as plt
 import seaborn as sns
-import numpy as np  # Adicionado para lidar com potenciais issues numéricas
 
+# Configuração geral do Streamlit
+st.set_page_config(layout="wide", page_title="Dashboard Imobiliário Integrado")
 
-# --- Funções de Análise (Adaptadas do script anterior) ---
+# --- Funções de Carregamento de Dados ---
 
-@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."""
+@st.cache_data
+def load_data_anova():
+    """Carrega o Ames Housing Dataset e retorna para o módulo ANOVA."""
     urls_tentativas = [
         "https://raw.githubusercontent.com/Viniciusalgueiro/Ameshousing/refs/heads/main/AmesHousing.csv"
     ]
@@ -25,13 +30,11 @@ def load_data():
             url_carregada = url
             break
         except Exception:
-            continue  # Tenta a próxima URL
+            continue
 
     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
@@ -40,38 +43,107 @@ def load_data():
     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)
 
+    # Identificar colunas categóricas potenciais (inclui numéricas discretas < 20 níveis)
     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_numericas_discretas = [
+        col for col in df.select_dtypes(include=np.number).columns
+        if df[col].nunique() < 20 and col != coluna_preco_nome
+    ]
     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)))
+        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()
 
 
+@st.cache_data
+def load_data_reg():
+    """Carrega o Ames Housing Dataset e retorna para o módulo de Regressão."""
+    fixed_url = "https://raw.githubusercontent.com/Viniciusalgueiro/Ameshousing/refs/heads/main/AmesHousing.csv"
+    try:
+        df = pd.read_csv(fixed_url)
+        url_carregada = fixed_url
+    except Exception as e:
+        return None, None, [], [], []
+
+    st.success(f"Dataset carregado com sucesso de: {url_carregada} (Shape: {df.shape})")
+    df.columns = df.columns.str.replace('[^A-Za-z0-9_]+', '', regex=True).str.lower()
+
+    coluna_preco_nome = None
+    possible_price_cols = ['saleprice', 'sale_price', 'price']
+    for col_candidate in possible_price_cols:
+        if col_candidate in df.columns:
+            if coluna_preco_nome is None:
+                coluna_preco_nome = 'saleprice'
+                if col_candidate != 'saleprice':
+                    df.rename(columns={col_candidate: 'saleprice'}, inplace=True)
+            break
+
+    if coluna_preco_nome is None:
+        for col_candidate in df.columns:
+            if 'price' in col_candidate and 'sale' in col_candidate:
+                coluna_preco_nome = 'saleprice'
+                if col_candidate != 'saleprice':
+                    df.rename(columns={col_candidate: 'saleprice'}, inplace=True)
+                st.warning(f"Coluna de preço identificada como '{col_candidate}' e renomeada para 'saleprice'.")
+                break
+
+    if coluna_preco_nome is None:
+        return df, None, [], [], df.columns.tolist()
+
+    df[coluna_preco_nome] = pd.to_numeric(df[coluna_preco_nome], errors='coerce')
+    df.dropna(subset=[coluna_preco_nome], inplace=True)
+
+    # Colunas contínuas e categóricas potenciais
+    vars_sempre_continuas_para_reg = [
+        'grlivarea', 'overallqual', 'yearbuilt', 'totalbsmtsf', 'lotarea',
+        'masvnrarea', 'bsmtfinsf1', 'bsmtunfsf', '1stflrsf', '2ndflrsf',
+        'garagearea', 'wooddecksf', 'openporchsf', 'yrsold', 'lotfrontage',
+        'garageyrblt', 'screensf', 'poolarea', 'miscval', 'mosold',
+        'lowqualfinsf', 'bsmthalfbath', 'fullbath', 'halfbath',
+        'bedroomabvgr', 'kitchenabvgr', 'totrmsabvgrd', 'fireplaces', 'garagecars'
+    ]
+
+    colunas_categoricas_potenciais = df.select_dtypes(include=['object', 'category']).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 and col not in vars_sempre_continuas_para_reg
+    ]
+    colunas_categoricas_potenciais.extend(colunas_numericas_discretas)
+    colunas_categoricas_potenciais = sorted(
+        list(set(col for col in colunas_categoricas_potenciais if col in df.columns and col != coluna_preco_nome))
+    )
+
+    colunas_continuas_potenciais = [
+        col for col in df.select_dtypes(include=np.number).columns
+        if (
+            col not in colunas_categoricas_potenciais or col in vars_sempre_continuas_para_reg
+        ) and col != coluna_preco_nome
+    ]
+    colunas_continuas_potenciais = sorted(list(set(col for col in colunas_continuas_potenciais if col in df.columns)))
+
+    return df, coluna_preco_nome, colunas_categoricas_potenciais, colunas_continuas_potenciais, df.columns.tolist()
+
+
+# --- Funções de ANOVA ---
+
 def perform_anova_for_variable(df_analysis, var_cat, col_preco):
-    """Executa ANOVA e testes de pressupostos para uma variável."""
+    """Executa ANOVA e testes de pressupostos para uma variável categórica."""
     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."
+    df_var.dropna(inplace=True)
+    if df_var[var_cat].nunique() < 2 or len(df_var) < 10:
+        results["error"] = "Dados insuficientes ou poucos níveis após limpeza."
         return results
 
     formula = f'{col_preco} ~ C({var_cat})'
@@ -79,39 +151,35 @@ def perform_anova_for_variable(df_analysis, var_cat, col_preco):
         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
+            results["p_valor_anova"] = results["anova_table"].loc[f'C({var_cat})', 'PR(>F)']
+        else:
+            results["p_valor_anova"] = results["anova_table"]['PR(>F)'].iloc[0]
 
         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
+                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
+        # 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)
+            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')
@@ -119,17 +187,18 @@ def perform_anova_for_variable(df_analysis, var_cat, col_preco):
         plt.tight_layout()
         results["plots"]["normalidade"] = fig_norm
 
-        # 2. Homocedasticidade (Teste de Levene)
+        # Teste de homocedasticidade (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
+        grupos_validos = [g for g in grupos if len(g) >= 2]
         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
+            if p_levene >= 0.05:
+                homocedasticidade_ok = True
         results["homocedasticidade_ok"] = homocedasticidade_ok
 
-        # 3. Kruskal-Wallis (se necessário)
+        # Teste de 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)
@@ -139,11 +208,11 @@ def perform_anova_for_variable(df_analysis, var_cat, col_preco):
         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
+        if 5 < unique_cats < 50:
             try:
                 order_boxplot = df_var.groupby(var_cat)[col_preco].median().sort_values().index
             except Exception:
-                order_boxplot = df_var[var_cat].unique()  # Fallback
+                order_boxplot = df_var[var_cat].unique()
 
         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)
@@ -151,185 +220,490 @@ def perform_anova_for_variable(df_analysis, var_cat, col_preco):
             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}`")
+    return results
 
-            # 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
+# --- Função de Regressão Linear ---
+
+def run_linear_regression_analysis(df_original, target_column_name, selected_cont_vars, selected_cat_vars):
+    """Executa a análise de regressão linear."""
+    results_regression = {}
+    df_reg = df_original.copy()
+    all_selected_vars = selected_cont_vars + selected_cat_vars
+
+    if not all_selected_vars:
+        return {"error": "Nenhuma variável explicativa selecionada."}
+
+    actual_selected_vars = [var for var in all_selected_vars if var in df_reg.columns]
+    missing_vars = [var for var in all_selected_vars if var not in df_reg.columns]
+    if missing_vars:
+        st.warning(f"Variáveis ignoradas (não encontradas): {missing_vars}")
+        selected_cont_vars = [v for v in selected_cont_vars if v in actual_selected_vars]
+        selected_cat_vars = [v for v in selected_cat_vars if v in actual_selected_vars]
+        all_selected_vars = selected_cont_vars + selected_cat_vars
+        if not all_selected_vars:
+            return {"error": "Nenhuma variável válida para regressão após filtragem."}
+
+    df_reg = df_reg[all_selected_vars + [target_column_name]].copy()
+    df_reg.dropna(subset=all_selected_vars + [target_column_name], inplace=True)
+    if df_reg.empty:
+        return {"error": "DataFrame vazio após remoção de NaNs."}
+
+    if df_reg[target_column_name].min() > 0:
+        df_reg['log_saleprice'] = np.log(df_reg[target_column_name])
+    else:
+        df_reg['log_saleprice'] = np.log1p(df_reg[target_column_name])
+    new_target_column = 'log_saleprice'
+
+    transformed_continuous_vars = []
+    for var in selected_cont_vars:
+        log_var_name = f'log_{var}'
+        if var in df_reg.columns:
+            if var in ['overallqual', 'yearbuilt', 'yrsold', 'mosold', 'fireplaces', 'garagecars',
+                       'bsmthalfbath', 'fullbath', 'halfbath', 'bedroomabvgr', 'kitchenabvgr', 'totrmsabvgrd']:
+                transformed_continuous_vars.append(var)
+            elif df_reg[var].min() > 0:
+                df_reg[log_var_name] = np.log(df_reg[var])
+                transformed_continuous_vars.append(log_var_name)
+            else:
+                df_reg[log_var_name] = np.log1p(df_reg[var])
+                transformed_continuous_vars.append(log_var_name)
+
+    processed_categorical_vars = []
+    for cat_var in selected_cat_vars:
+        if cat_var in df_reg.columns:
+            if df_reg[cat_var].dtype not in ['object', 'category']:
+                df_reg[cat_var] = df_reg[cat_var].astype('category')
+            processed_categorical_vars.append(cat_var)
+
+    df_reg = pd.get_dummies(df_reg, columns=processed_categorical_vars, drop_first=True, dtype=float)
+
+    final_explanatory_vars = [var for var in transformed_continuous_vars if var in df_reg.columns]
+    for cat_orig in processed_categorical_vars:
+        dummy_cols = [col for col in df_reg.columns if col.startswith(f"{cat_orig}_")]
+        final_explanatory_vars.extend(dummy_cols)
+
+    final_explanatory_vars = sorted(set(final_explanatory_vars))
+    final_explanatory_vars = [
+        var for var in final_explanatory_vars
+        if var in df_reg.columns and df_reg[var].isnull().sum() < len(df_reg) and df_reg[var].std(skipna=True) > 0
+    ]
 
-            resultados_var = perform_anova_for_variable(df_analise_var, var_analisada, coluna_preco)
+    if not final_explanatory_vars:
+        return {"error": "Nenhuma variável explicativa válida após pré-processamento."}
 
-            if "error" in resultados_var:
-                st.error(f"Erro ao analisar '{var_analisada}': {resultados_var['error']}")
-                continue
+    X = df_reg[final_explanatory_vars]
+    y = df_reg[new_target_column]
+    X = sm.add_constant(X, has_constant='add')
 
-            # 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.")
+    try:
+        model = sm.OLS(y, X).fit()
+        results_regression['model_summary_obj'] = model.summary()
+        results_regression['model_object'] = model
+    except Exception as e:
+        return {"error": f"Erro ao ajustar modelo: {str(e)}. Variáveis em X: {X.columns.tolist()}"}
+
+    fitted_values = model.fittedvalues
+    r_squared = model.rsquared
+    adj_r_squared = model.rsquared_adj
+    rmse_log = np.sqrt(mean_squared_error(y, fitted_values))
+    mae_log = mean_absolute_error(y, fitted_values)
+    results_regression['performance_metrics'] = {
+        'R-squared': r_squared,
+        'Adjusted R-squared': adj_r_squared,
+        'RMSE (log)': rmse_log,
+        'MAE (log)': mae_log
+    }
+
+    # Interpretação de coeficientes
+    coeff_notes = """
+    **Interpretação dos Coeficientes (`log_saleprice`):**
+    - Variáveis contínuas transformadas em log (ex: `log_grlivarea`): 
+      Aumento de 1% na variável resulta em ~[coef * 1]% de variação no `saleprice`.
+    - Variáveis contínuas não transformadas (ex: `overallqual`): 
+      Aumento unitário resulta em ~[(exp(coef)-1)*100]% de variação no `saleprice`.
+    - Dummies (ex: `neighborhood_stonebr`): 
+      Presença da categoria resulta em ~[(exp(coef)-1)*100]% de variação no `saleprice`.
+    **Significância:** Verifique `P>|t|` < 0.05.
+    """
+    results_regression['coefficients_interpretation_notes'] = coeff_notes
+
+    # Recomendações práticas
+    recommendations_data = []
+    if hasattr(model, 'params') and hasattr(model, 'pvalues'):
+        params_df = pd.DataFrame({'Coeficiente': model.params, 'P-valor': model.pvalues})
+        significant_params = params_df[params_df['P-valor'] < 0.05]
+        if 'const' in significant_params.index:
+            significant_params = significant_params.drop('const')
+
+        if not significant_params.empty:
+            for var, row in significant_params.iterrows():
+                coef = row['Coeficiente']
+                is_log = var.startswith("log_") and var in transformed_continuous_vars
+                original_var = var.replace("log_", "") if is_log else var
+                display_name = original_var.replace('_', ' ').title()
+
+                # Dummies
+                is_dummy = False
+                for cat_orig in selected_cat_vars:
+                    if var.startswith(f"{cat_orig}_"):
+                        is_dummy = True
+                        parts = var.split('_', 1)
+                        cat_display = parts[1].replace('_', ' ').title() if len(parts) > 1 else "Categoria"
+                        display_name = f"{cat_orig.replace('_', ' ').title()}: {cat_display}"
+                        break
+
+                if is_log:
+                    tipo = "Aumento Percentual (elasticidade)"
+                    magnitude = f"{coef:.2f}% de variação no preço para 1% de aumento"
+                    interpret = f"1% em '{original_var.title()}' causa {coef:.2f}% no preço."
                 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.")
+                    percentage_change = (np.exp(coef) - 1) * 100
+                    tipo = "Aumento Percentual (nível ou dummy)"
+                    magnitude = f"{percentage_change:.2f}% de variação no preço"
+                    if is_dummy:
+                        interpret = f"Presença em '{display_name}' causa {percentage_change:.2f}% no preço."
+                    else:
+                        interpret = f"Aumento unitário em '{display_name}' causa {percentage_change:.2f}% no preço."
+
+                recommendations_data.append({
+                    "Variável": display_name,
+                    "Tipo de Impacto": tipo,
+                    "Interpretação": interpret,
+                    "Magnitude Estimada": magnitude
+                })
+        else:
+            recommendations_data.append({
+                "Variável": "N/A",
+                "Tipo de Impacto": "-",
+                "Interpretação": "Nenhum coeficiente significativo.",
+                "Magnitude Estimada": "-"
+            })
+    else:
+        recommendations_data.append({
+            "Variável": "N/A",
+            "Tipo de Impacto": "-",
+            "Interpretação": "Modelo não ajustado.",
+            "Magnitude Estimada": "-"
+        })
+
+    results_regression['practical_recommendations_table_data'] = recommendations_data
+    return results_regression
+
+
+# --- Lógica de Navegação via Botões ---
+
+# Inicializa o estado de página (ANOVA ou REGRESSAO)
+if 'page' not in st.session_state:
+    st.session_state.page = 'ANOVA'
+
+# Botões de navegação
+col1, col2 = st.columns([1, 1])
+with col1:
+    if st.button('📊 ANOVA'):
+        st.session_state.page = 'ANOVA'
+with col2:
+    if st.button('📈 Regressão'):
+        st.session_state.page = 'REGRESSAO'
+
+st.markdown("---")
+
+# --- Página ANOVA ---
+if st.session_state.page == 'ANOVA':
+    st.title("🏠 Dashboard de ANOVA Imobiliária")
+    st.markdown("""
+    Esta seção permite realizar Análises de Variância (ANOVA) no Ames Housing Dataset,
+    investigando como diferentes variáveis categóricas impactam o preço de venda dos imóveis.
+    """)
+
+    df_anova, coluna_preco_anova, colunas_categoricas_selecionaveis, todas_colunas_anova = load_data_anova()
+
+    if df_anova is not None and coluna_preco_anova is not None:
+        st.header("1. Visão Geral dos Dados (ANOVA)")
+        if st.checkbox("Mostrar amostra dos dados"):
+            st.dataframe(df_anova.head())
+        st.write(f"Total de registros carregados: {len(df_anova)}")
+        st.write(f"Coluna alvo (preço): `{coluna_preco_anova}`")
+
+        st.sidebar.header("⚙️ Configurações ANOVA")
+        variaveis_selecionadas = st.sidebar.multiselect(
+            "Escolha 1 a 3 variáveis categóricas para ANOVA:",
+            options=colunas_categoricas_selecionaveis,
+            max_selections=3
+        )
+
+        if variaveis_selecionadas:
+            st.header("2. Resultados da Análise ANOVA")
+            st.markdown(f"Analisando **{', '.join(variaveis_selecionadas)}** sobre **{coluna_preco_anova}**.")
+
+            for var_analisada in variaveis_selecionadas:
+                st.subheader(f"Análise para: `{var_analisada}`")
+                df_analise_var = df_anova[[var_analisada, coluna_preco_anova]].copy()
+                df_analise_var.dropna(subset=[var_analisada, coluna_preco_anova], inplace=True)
+
+                if df_analise_var.empty or df_analise_var[var_analisada].nunique() < 2:
+                    st.warning(f"Dados insuficientes ou poucos níveis para '{var_analisada}'. Pulando.")
+                    continue
+
+                resultados_var = perform_anova_for_variable(df_analise_var, var_analisada, coluna_preco_anova)
+                if "error" in resultados_var:
+                    st.error(f"Erro ao analisar '{var_analisada}': {resultados_var['error']}")
+                    continue
+
+                # 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"✅ Diferença significativa (p-valor: {p_anova:.4e}).")
+                        else:
+                            st.info(f"ℹ️ Sem diferença significativa (p-valor: {p_anova:.4e}).")
+
+                # Pressupostos e Testes Alternativos
+                with st.expander("Verificar Pressupostos 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}")
+
+                    if resultados_var.get("normalidade_ok"):
+                        st.success("✅ Resíduos parecem normalmente distribuídos.")
+                    else:
+                        st.warning("⚠️ Resíduos NÃO parecem normalmente distribuídos.")
+
+                    if "normalidade" in resultados_var["plots"]:
+                        st.pyplot(resultados_var["plots"]["normalidade"])
+
+                    st.markdown("**Homogeneidade das Variâncias (Levene):**")
+                    if "levene_test" in resultados_var:
+                        stat_l, p_l = resultados_var["levene_test"]
+                        st.write(f"Levene: Estatística={stat_l:.4f}, P-valor={p_l:.4e}")
+                        if resultados_var.get("homocedasticidade_ok"):
+                            st.success("✅ Variâncias homogêneas.")
+                        else:
+                            st.warning("⚠️ Variâncias NÃO homogêneas.")
+                    else:
+                        st.write("Levene não pôde ser realizado (insuficiente).")
+
+                    if "kruskal_test" in resultados_var:
+                        st.markdown("**Kruskal-Wallis (Não Paramétrico):**")
+                        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("✅ Diferença significativa nas medianas.")
+                        else:
+                            st.info("ℹ️ Sem diferença significativa nas medianas.")
+
+                # Boxplot
+                if "boxplot" in resultados_var["plots"]:
+                    st.markdown("**Distribuição de Preços por Categoria:**")
+                    st.pyplot(resultados_var["plots"]["boxplot"])
+
+                st.markdown("---")
+
+        elif not variaveis_selecionadas:
+            st.sidebar.warning("Selecione ao menos uma variável para executar a ANOVA.")
+
+        st.sidebar.markdown("---")
+        st.sidebar.markdown("Desenvolvido para análise imobiliária.")
+
+        if variaveis_selecionadas:
+            st.header("3. Insights Gerais e Recomendações ANOVA")
+            with st.expander("Ver Recomendações"):
+                st.markdown("""
+                ### Como interpretar:
+                - ANOVA ajuda a entender se variáveis categóricas (ex: estilo da casa, ano, telhado)  
+                  têm associação significativa com o preço.
+                - **Variáveis com p-valor < 0.05**: sugerem diferença estatisticamente significativa.
+                - Use essas informações para ajustar estratégia de precificação e marketing.
+                - Para análise multivariada, prossiga para Regressão Linear Múltipla.
+                """)
+
+    else:
+        if df_anova is None:
+            st.warning("Aguardando carregamento dos dados ou verifique as URLs.")
+        elif coluna_preco_anova is None:
+            st.error(f"Coluna de preço não encontrada. Verifique as colunas: {todas_colunas_anova}")
+
+
+# --- Página REGRESSÃO ---
+elif st.session_state.page == 'REGRESSAO':
+    st.title("🏠 Dashboard de Regressão Imobiliária")
+    st.markdown("""
+    Esta seção permite realizar Modelagem Preditiva com Regressão Linear Múltipla
+    no Ames Housing Dataset para entender o impacto de variáveis contínuas e categóricas no preço.
+    """)
+
+    df_reg, coluna_preco_reg, colunas_categoricas_reg, colunas_continuas_reg, todas_colunas_reg = load_data_reg()
+
+    if df_reg is not None and coluna_preco_reg is not None:
+        st.header("1. Visão Geral dos Dados (Regressão)")
+        if st.checkbox("Mostrar amostra aleatória dos dados"):
+            st.dataframe(df_reg.sample(min(5, len(df_reg))))
+        st.write(f"Total registros: {len(df_reg)}")
+        st.write(f"Coluna alvo (preço): `{coluna_preco_reg}`")
+
+        # Configurações no sidebar
+        st.sidebar.title("⚙️ Configurações Regressão")
+        st.sidebar.header("Seleção de Variáveis")
+        st.sidebar.markdown("Escolha 4 a 6 variáveis (≥1 contínua e ≥1 categórica).")
+
+        default_cont = ['grlivarea', 'overallqual', 'yearbuilt', 'totalbsmtsf']
+        valid_default_cont = [v for v in default_cont if v in colunas_continuas_reg]
+        if not valid_default_cont and colunas_continuas_reg:
+            valid_default_cont = colunas_continuas_reg[:1]
+
+        reg_continuous_vars = st.sidebar.multiselect(
+            "Variáveis Contínuas:",
+            options=colunas_continuas_reg,
+            default=valid_default_cont,
+            key="reg_cont_vars"
+        )
+
+        default_cat = ['neighborhood', 'housestyle']
+        valid_default_cat = [v for v in default_cat if v in colunas_categoricas_reg]
+        if not valid_default_cat and colunas_categoricas_reg:
+            valid_default_cat = colunas_categoricas_reg[:1]
+
+        reg_categorical_vars = st.sidebar.multiselect(
+            "Variáveis Categóricas:",
+            options=colunas_categoricas_reg,
+            default=valid_default_cat,
+            key="reg_cat_vars"
+        )
+
+        total_vars = len(reg_continuous_vars) + len(reg_categorical_vars)
+        valid_selection = True
+        if not (4 <= total_vars <= 6):
+            st.sidebar.warning(f"Selecione entre 4 e 6 variáveis (total atual: {total_vars}).")
+            valid_selection = False
+        if not reg_continuous_vars:
+            st.sidebar.warning("Selecione ao menos 1 variável contínua.")
+            valid_selection = False
+        if not reg_categorical_vars:
+            st.sidebar.warning("Selecione ao menos 1 variável categórica.")
+            valid_selection = False
+
+        st.markdown("---")
+        st.header("2. Análise Exploratória das Variáveis Selecionadas")
+
+        if reg_continuous_vars or reg_categorical_vars:
+            if st.checkbox("Mostrar Distribuições das Variáveis Selecionadas", value=False):
+                st.markdown("##### Distribuições das Variáveis Contínuas")
+                for var_cont in reg_continuous_vars:
+                    if var_cont in df_reg.columns:
+                        fig, ax = plt.subplots(figsize=(6, 3))
+                        sns.histplot(df_reg[var_cont], kde=True, ax=ax, bins=30)
+                        ax.set_title(f"Distribuição de {var_cont}")
+                        st.pyplot(fig)
                     else:
-                        st.warning("⚠️ Variâncias NÃO parecem ser homogêneas.")
+                        st.warning(f"'{var_cont}' não encontrada para plotar.")
+
+                st.markdown("##### Contagem das Categorias das Variáveis Categóricas")
+                for var_cat in reg_categorical_vars:
+                    if var_cat in df_reg.columns:
+                        fig, ax = plt.subplots(figsize=(7, 4))
+                        if df_reg[var_cat].nunique() > 5:
+                            sns.countplot(y=df_reg[var_cat], ax=ax,
+                                          order=df_reg[var_cat].value_counts().index, palette="viridis")
+                        else:
+                            sns.countplot(x=df_reg[var_cat], ax=ax,
+                                          order=df_reg[var_cat].value_counts().index, palette="viridis")
+                            plt.xticks(rotation=45, ha="right")
+                        ax.set_title(f"Contagem de {var_cat}")
+                        plt.tight_layout()
+                        st.pyplot(fig)
+                    else:
+                        st.warning(f"'{var_cat}' não encontrada para plotar contagem.")
+
+            if st.checkbox("Mostrar Mapa de Correlação das Contínuas + Preço", value=False):
+                st.markdown("##### Mapa de Correlação")
+                vars_corr = [var for var in reg_continuous_vars if var in df_reg.columns] + [coluna_preco_reg]
+                if len(vars_corr) > 1:
+                    corr_matrix = df_reg[vars_corr].corr()
+                    fig_corr, ax_corr = plt.subplots(
+                        figsize=(min(10, len(vars_corr) * 1.5), min(8, len(vars_corr) * 1.2))
+                    )
+                    sns.heatmap(corr_matrix, annot=True, cmap="coolwarm", fmt=".2f", linewidths=.5, ax=ax_corr)
+                    ax_corr.set_title("Mapa de Correlação")
+                    st.pyplot(fig_corr)
                 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.")
+                    st.info("Selecione ao menos duas variáveis numéricas para o mapa de correlação.")
+            st.markdown("---")
+
+        if st.button("Executar Regressão Linear", disabled=not valid_selection):
+            with st.spinner("Executando regressão..."):
+                output_reg = run_linear_regression_analysis(df_reg, coluna_preco_reg,
+                                                            reg_continuous_vars, reg_categorical_vars)
+            if "error" in output_reg:
+                st.error(output_reg["error"])
+            else:
+                st.subheader("Resultados do Modelo de Regressão")
+
+                model_summary_obj = output_reg.get('model_summary_obj')
+                if model_summary_obj:
+                    st.markdown("##### Sumário Geral do Modelo:")
+                    sum_table0 = pd.read_html(model_summary_obj.tables[0].as_html(), header=None, index_col=None)[0]
+                    st.table(sum_table0.iloc[:, :2].rename(columns={0: "Métrica", 1: "Valor"}))
+                    st.table(sum_table0.iloc[:, 2:].rename(columns={2: "Métrica", 3: "Valor"}))
+
+                    st.markdown("##### Coeficientes do Modelo:")
+                    sum_table1 = pd.read_html(model_summary_obj.tables[1].as_html(), header=0, index_col=0)[0]
+                    st.dataframe(sum_table1.style.format({
+                        "coef": "{:.4f}", "std err": "{:.4f}", "t": "{:.3f}", "P>|t|": "{:.3e}",
+                        "[0.025": "{:.4f}", "0.975]": "{:.4f}"
+                    }))
+
+                    if len(model_summary_obj.tables) > 2:
+                        st.markdown("##### Outras Estatísticas e Notas:")
+                        notes_html = model_summary_obj.tables[2].as_html()
+                        notes_df = pd.read_html(notes_html, header=None, index_col=None)[0]
+                        for i in range(len(notes_df)):
+                            line = notes_df.iloc[i].tolist()
+                            st.text("  ".join([str(x) for x in line if pd.notna(x)]))
+
+                st.subheader("Métricas de Desempenho")
+                if 'performance_metrics' in output_reg:
+                    metrics_df = pd.DataFrame.from_dict(output_reg['performance_metrics'], orient='index', columns=['Valor'])
+                    st.table(metrics_df.style.format("{:.4f}"))
+                    st.markdown("""
+                    * **R-squared / R-squared Ajustado:** Variância explicada pelo modelo.
+                    * **RMSE (log) / MAE (log):** Erros médios na escala logarítmica.
+                    """)
+
+                st.subheader("Interpretação dos Coeficientes")
+                if 'coefficients_interpretation_notes' in output_reg:
+                    st.markdown(output_reg['coefficients_interpretation_notes'])
+
+                st.subheader("Recomendações Práticas")
+                if 'practical_recommendations_table_data' in output_reg:
+                    recom_df = pd.DataFrame(output_reg['practical_recommendations_table_data'])
+                    if not recom_df.empty:
+                        st.dataframe(recom_df)
                     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.")
-# No final do script Streamlit, após o loop de análise das variáveis
-
-if variaveis_selecionadas: # Somente mostrar se alguma análise foi feita
-    st.header("3. Insights Gerais e Recomendações")
-    with st.expander("Ver Análise Detalhada e Recomendações"):
-        st.markdown("""
-        ### Como Interpretar os Resultados para Tomada de Decisão:
-
-        A análise ANOVA nos ajuda a entender se uma característica específica da casa (como estilo da casa,
-        ano da venda, ou estilo do telhado) tem uma associação estatisticamente significativa com o preço
-        médio de venda.
-
-        **Para as variáveis analisadas (`HouseStyle`, `YrSold`, `RoofStyle`):**
-
-        #### `HouseStyle` (Estilo da Moradia):
-        * **Impacto Geral:** Geralmente significativo. Estilos diferentes (Térrea, Dois Andares, Níveis Divididos)
-            atraem diferentes compradores e têm diferentes custos e áreas construídas.
-        * **Orientação para Corretores:** Utilize o estilo para segmentar o marketing e justificar faixas de preço.
-        * **Orientação para Investidores:** Analise a popularidade e o potencial de valorização de diferentes estilos
-            na sua área de interesse.
-
-        #### `YrSold` (Ano da Venda):
-        * **Impacto Geral:** Pode ser significativo se o mercado passou por mudanças (altas ou baixas) durante
-            os anos analisados (ex: 2006-2010). Reflete tendências macroeconômicas.
-        * **Orientação para Corretores:** Fornece contexto histórico para a precificação atual e ajuda a gerenciar
-            expectativas.
-        * **Orientação para Investidores:** Sublinha a importância de entender os ciclos de mercado, embora os dados
-            históricos de `YrSold` não prevejam o futuro diretamente.
-
-        #### `RoofStyle` (Estilo do Telhado):
-        * **Impacto Geral:** Pode ser significativo. Certos estilos (ex: Quatro Águas vs. Duas Águas) podem estar
-            associados a diferentes níveis de custo, durabilidade e estética.
-        * **Orientação para Corretores:** Um detalhe que pode agregar valor, especialmente se o telhado for novo
-            ou de um estilo particularmente desejável ou durável.
-        * **Orientação para Investidores:** O custo de manutenção e substituição pode variar com o estilo do telhado.
-            A condição do telhado é mais crítica que o estilo em si, mas o estilo influencia o custo.
-
-        **Recomendações Gerais:**
-        * **Corretores:** Usem esses insights para refinar suas estratégias de precificação, marketing e aconselhamento
-            aos clientes. Uma casa não é apenas um conjunto de quartos, mas um conjunto de características que, juntas,
-            determinam seu valor.
-        * **Investidores:** Considerem como essas características (e outras) se alinham com seus objetivos de
-            investimento, seja para renda, "flipping" ou valorização a longo prazo. Focar em características
-            que têm um impacto positivo e duradouro no valor é fundamental.
-
-        *Lembre-se que a ANOVA univariada mostra a relação de uma variável por vez com o preço.
-        Para uma análise mais completa do impacto combinado de múltiplas variáveis, a Regressão Linear (Parte II da sua tarefa original) seria o próximo passo.*
-        """)
+                        st.info("Nenhuma recomendação gerada (verifique significância).")
+
+        st.sidebar.markdown("---")
+        st.sidebar.info("Dashboard de Regressão Imobiliária")
+
+    else:
+        if df_reg is None:
+            st.error("Falha ao carregar dados. Verifique a conexão ou a URL.")
+        elif coluna_preco_reg is None:
+            st.error(f"Coluna de preço não identificada. Colunas disponíveis: {todas_colunas_reg}")
+        else:
+            if not colunas_categoricas_reg and not colunas_continuas_reg:
+                st.error("Nenhuma coluna adequada identificada para regressão.")
+
+