Update app.py

app.py

@@ -22,8 +22,13 @@ class HousePricePredictor:
         self.scaler = None
         self.df = None
         self.is_trained = False
-        self.selected_features = []
+        self.selected_features = None
         self._data_loaded = False
+        self.stats = {
+            'n_imoveis': 0,
+            'n_caracteristicas': 0,
+            'preco_medio': 0
+        }
         
     def load_data(self):
         """Carrega dados do arquivo kc_house_data.csv"""
@@ -37,6 +42,13 @@ class HousePricePredictor:
                 # Limpeza básica dos dados
                 self._clean_data()
                 
+                # Atualizar estatísticas
+                self.stats = {
+                    'n_imoveis': self.df.shape[0],
+                    'n_caracteristicas': self.df.shape[1],
+                    'preco_medio': self.df['price'].mean()
+                }
+                
                 self._data_loaded = True
                 print(f"✅ Dados carregados: {self.df.shape[0]} imóveis × {self.df.shape[1]} características")
                 return f"✅ Dados carregados: {self.df.shape[0]} imóveis × {self.df.shape[1]} características"
@@ -75,17 +87,6 @@ class HousePricePredictor:
             numeric_features.remove('price')
         return numeric_features
     
-    def get_top_features_by_correlation(self, n=6):
-        """Retorna as top n features por correlação com price"""
-        if self.df is None:
-            return []
-        correlations = self.df.corr()['price'].abs().sort_values(ascending=False)
-        top_features = []
-        for feature in correlations.index:
-            if feature != 'price' and len(top_features) < n:
-                top_features.append(feature)
-        return top_features
-    
     def get_dataset_stats(self):
         """Retorna estatísticas do dataset para display seguro"""
         if self.df is not None:
@@ -158,8 +159,7 @@ class HousePricePredictor:
                 'rmse_test': rmse_test,
                 'mae_test': mae_test,
                 'top_features': coeficientes.to_dict('records'),
-                'selected_features': selected_features,
-                'n_features': len(selected_features)
+                'selected_features': selected_features
             }
             
         except Exception as e:
@@ -198,59 +198,50 @@ print("🚀 Iniciando aplicação...")
 initial_message = predictor.load_data()
 initial_features = predictor.get_numeric_features()
 dataset_stats = predictor.get_dataset_stats()
-top_features = predictor.get_top_features_by_correlation(6)
 print(f"📊 Features disponíveis: {initial_features}")
 
 # Funções para a interface Gradio
-def create_feature_checkboxes():
-    """Cria os checkboxes de features"""
+def load_data_action():
+    """Carrega os dados - função para o botão"""
+    message = predictor.load_data()
     features = predictor.get_numeric_features()
-    checkboxes = []
     
+    # Criar checkboxes para features
+    feature_checkboxes = []
     if features and predictor.df is not None:
+        # Calcular correlações com preço
         correlations = predictor.df.corr()['price'].abs().sort_values(ascending=False)
         
+        # Selecionar automaticamente as 6 features mais correlacionadas
+        top_features = []
+        for feature in correlations.index:
+            if feature != 'price' and len(top_features) < 6:
+                top_features.append(feature)
+        
         for feature in features:
             corr_value = correlations.get(feature, 0)
-            is_selected = feature in top_features
-            
-            checkboxes.append(
+            feature_checkboxes.append(
                 gr.Checkbox(
                     label=f"{feature} (corr: {corr_value:.3f})",
-                    value=is_selected,
+                    value=feature in top_features,
                     info=f"Média: {predictor.df[feature].mean():.1f}"
                 )
             )
     
-    return checkboxes
+    return message, gr.Column(feature_checkboxes), gr.update(visible=True)
 
-def update_selected_features_display(*checkbox_values):
-    """Atualiza o display das features selecionadas"""
+def get_selected_features_from_checkboxes(*checkbox_values):
+    """Converte valores dos checkboxes para lista de features selecionadas"""
     features = predictor.get_numeric_features()
     selected = []
-    
     for i, is_checked in enumerate(checkbox_values):
         if is_checked and i < len(features):
             selected.append(features[i])
-    
-    if selected:
-        features_text = "**Features selecionadas:**\n" + "\n".join([f"• {feat}" for feat in selected])
-        features_text += f"\n\n**Total:** {len(selected)} features"
-        return features_text, gr.update(visible=True)
-    else:
-        return "❌ Nenhuma feature selecionada", gr.update(visible=False)
+    return selected
 
 def train_model_action(*checkbox_values):
     """Treina o modelo com features selecionadas"""
-    features = predictor.get_numeric_features()
-    selected_features = []
-    
-    for i, is_checked in enumerate(checkbox_values):
-        if is_checked and i < len(features):
-            selected_features.append(features[i])
-    
-    if not selected_features:
-        return "❌ Nenhuma feature selecionada. Selecione pelo menos uma feature.", None, gr.update(visible=False), gr.update(visible=False)
+    selected_features = get_selected_features_from_checkboxes(*checkbox_values)
     
     success, result = predictor.train_model(selected_features)
     
@@ -264,19 +255,153 @@ def train_model_action(*checkbox_values):
         - **RMSE Teste**: ${result['rmse_test']:,.0f}
         - **MAE Teste**: ${result['mae_test']:,.0f}
         
-        ### 🎯 Features por Importância ({result['n_features']} features):
+        ### 🎯 Features por Importância:
         """
         
         for i, feature in enumerate(result['top_features']):
             direction = "📈 Aumenta preço" if feature['Coeficiente'] > 0 else "📉 Diminui preço"
             metrics_text += f"\n{i+1}. **{feature['Feature']}**: {feature['Coeficiente']:.4f} ({direction})"
         
-        return metrics_text, result, gr.update(visible=True), gr.update(visible=True)
+        metrics_text += f"\n\n**Total de features usadas**: {len(selected_features)}"
+        
+        return metrics_text, result, gr.update(visible=True)
     else:
-        return result, None, gr.update(visible=False), gr.update(visible=False)
+        return result, None, gr.update(visible=False)
+
+def create_correlation_plot():
+    """Cria gráfico de correlação"""
+    if predictor.df is None:
+        return None
+    
+    try:
+        # Selecionar features mais importantes
+        numeric_cols = predictor.df.select_dtypes(include=[np.number]).columns.tolist()
+        if len(numeric_cols) > 8:
+            correlations = predictor.df.corr()['price'].abs().sort_values(ascending=False)
+            top_features = correlations.index[:8].tolist()
+        else:
+            top_features = numeric_cols
+        
+        corr_matrix = predictor.df[top_features].corr()
+        
+        fig, ax = plt.subplots(figsize=(12, 10))
+        sns.heatmap(corr_matrix, annot=True, fmt='.2f', cmap='RdYlBu', center=0,
+                   square=True, linewidths=0.5, cbar_kws={"shrink": 0.8}, ax=ax)
+        ax.set_title('🔗 Matriz de Correlação - Dataset Real King County', fontsize=14, fontweight='bold')
+        plt.tight_layout()
+        return fig
+    except Exception as e:
+        print(f"Erro no gráfico de correlação: {e}")
+        return None
+
+def create_feature_analysis_plot(selected_feature):
+    """Cria gráfico de análise para uma feature específica"""
+    if predictor.df is None or not selected_feature:
+        return None, None
+    
+    try:
+        # Gráfico 1: Distribuição
+        fig1, ax1 = plt.subplots(figsize=(10, 5))
+        ax1.hist(predictor.df[selected_feature], bins=30, edgecolor='black', alpha=0.7, color='skyblue')
+        ax1.axvline(predictor.df[selected_feature].mean(), color='red', linestyle='--', linewidth=2,
+                   label=f'Média: {predictor.df[selected_feature].mean():.2f}')
+        ax1.set_xlabel(selected_feature)
+        ax1.set_ylabel('Frequência')
+        ax1.set_title(f'📊 Distribuição de {selected_feature}')
+        ax1.legend()
+        ax1.grid(True, alpha=0.3)
+        plt.tight_layout()
+        
+        # Gráfico 2: Relação com preço
+        fig2, ax2 = plt.subplots(figsize=(10, 5))
+        
+        if predictor.df[selected_feature].nunique() < 10:
+            # Boxplot para variáveis categóricas
+            data_to_plot = []
+            categories = sorted(predictor.df[selected_feature].unique())
+            for cat in categories:
+                data_to_plot.append(predictor.df[predictor.df[selected_feature] == cat]['price'])
+            
+            ax2.boxplot(data_to_plot, labels=categories)
+        else:
+            # Scatter plot para variáveis contínuas
+            ax2.scatter(predictor.df[selected_feature], predictor.df['price'], alpha=0.3, s=20, color='steelblue')
+            # Linha de tendência
+            z = np.polyfit(predictor.df[selected_feature], predictor.df['price'], 1)
+            p = np.poly1d(z)
+            x_range = np.linspace(predictor.df[selected_feature].min(), predictor.df[selected_feature].max(), 100)
+            ax2.plot(x_range, p(x_range), "r--", linewidth=2, alpha=0.8, label='Tendência linear')
+            ax2.legend()
+        
+        ax2.set_xlabel(selected_feature)
+        ax2.set_ylabel('Preço ($)')
+        correlation = predictor.df[selected_feature].corr(predictor.df['price'])
+        ax2.set_title(f'💰 Preço vs {selected_feature} (Corr: {correlation:.3f})')
+        ax2.grid(True, alpha=0.3)
+        
+        # Formatar eixo y para dólares
+        ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x:,.0f}'))
+        
+        plt.tight_layout()
+        return fig1, fig2
+        
+    except Exception as e:
+        print(f"Erro nos gráficos de análise: {e}")
+        return None, None
+
+def create_price_distribution_plot():
+    """Cria gráfico da distribuição de preços"""
+    if predictor.df is None:
+        return None
+    
+    fig, ax = plt.subplots(figsize=(12, 6))
+    ax.hist(predictor.df['price'], bins=50, edgecolor='black', alpha=0.7, color='steelblue')
+    ax.axvline(predictor.df['price'].mean(), color='red', linestyle='--', linewidth=2, 
+               label=f'Média: ${predictor.df["price"].mean():,.0f}')
+    ax.axvline(predictor.df['price'].median(), color='green', linestyle='--', linewidth=2, 
+               label=f'Mediana: ${predictor.df["price"].median():,.0f}')
+    ax.set_xlabel('Preço ($)')
+    ax.set_ylabel('Número de Imóveis')
+    ax.set_title('🏠 Distribuição dos Preços - Dataset Real King County')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    
+    # Formatar eixo x para dólares
+    ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x:,.0f}'))
+    
+    plt.tight_layout()
+    return fig
+
+def get_feature_stats(feature):
+    """Retorna estatísticas de uma feature"""
+    if predictor.df is None or feature not in predictor.df.columns:
+        return "Selecione uma feature para ver estatísticas"
+    
+    stats = predictor.df[feature].describe()
+    correlation = predictor.df[feature].corr(predictor.df['price'])
+    
+    return f"""
+    ## 📈 Estatísticas de **{feature}**
+    
+    **Valores:**
+    - Média: {stats['mean']:.2f}
+    - Mediana: {stats['50%']:.2f}
+    - Desvio Padrão: {stats['std']:.2f}
+    - Mínimo: {stats['min']:.2f}
+    - Máximo: {stats['max']:.2f}
+    
+    **Distribuição:**
+    - 25º Percentil: {stats['25%']:.2f}
+    - 75º Percentil: {stats['75%']:.2f}
+    - Valores Únicos: {predictor.df[feature].nunique()}
+    
+    **Relação com Preço:**
+    - Correlação: {correlation:.3f}
+    - Interpretação: {'Forte' if abs(correlation) > 0.5 else 'Moderada' if abs(correlation) > 0.3 else 'Fraca'} relação
+    """
 
 def create_prediction_inputs(metrics_result):
-    """Cria inputs para previsão baseado nas features selecionadas"""
+    """Cria inputs para previsão"""
     if metrics_result is None or 'selected_features' not in metrics_result:
         return []
     
@@ -344,82 +469,238 @@ def predict_price_action(*feature_values):
     except Exception as e:
         return f"❌ Erro na previsão: {str(e)}", None
 
-# Interface Gradio simplificada com tudo em uma aba
-with gr.Blocks(title="🏠 Cálculo de Preço - King County Dataset Real") as demo:
+def get_dataset_info():
+    """Retorna informações do dataset para display seguro"""
+    stats = predictor.get_dataset_stats()
+    return f"""
+    **📊 Dataset Carregado:**
+    - **Arquivo**: kc_house_data.csv
+    - **Imóveis**: {stats['n_imoveis']:,}
+    - **Características**: {stats['n_caracteristicas']}
+    - **Preço Médio**: ${stats['preco_medio']:,.2f}
+    """
+
+# Interface Gradio
+with gr.Blocks(title="🏠 Análise e Previsão - King County Dataset Real") as demo:
     gr.Markdown(
         """
-        # 🏠 Cálculo de Preços de Imóveis - King County
-        ## 📊 Selecione Features, Treine Modelo e Faça Previsões
+        # 🏠 Análise e Previsão de Preços de Imóveis
+        ## 📊 Dataset Real - King County, Washington
+        
+        ### ℹ️ Sobre os Dados:
+        Este aplicativo utiliza o **dataset real** `kc_house_data.csv` do mercado imobiliário de King County.
+        Dados reais de vendas de imóveis com diversas características.
         """
     )
     
     # Status inicial
     initial_status = gr.Markdown(f"**Status:** {initial_message}")
+    dataset_info = gr.Markdown(get_dataset_info())
     
-    with gr.Row():
-        with gr.Column(scale=2):
-            gr.Markdown("### 📋 1. Selecione as Features para o Modelo")
+    with gr.Tab("🚀 Iniciar"):
+        gr.Markdown("### Bem-vindo ao Analisador de Dados Reais do King County!")
+        
+        gr.Markdown(get_dataset_info())
+        
+        gr.Markdown("""
+        **🎯 Funcionalidades:**
+        1. **📊 Análise Exploratória** - Gráficos com dados reais
+        2. **🤖 Treinar Modelo** - Machine Learning com features selecionadas  
+        3. **💰 Fazer Previsão** - Estime preços baseado no modelo
+        4. **📚 Explicações** - Entenda as análises
+        """)
+        
+        load_btn = gr.Button("🔄 Recarregar Dados", variant="secondary")
+        load_status = gr.Markdown()
+        feature_selection = gr.Column()
+        train_btn = gr.Button("🚀 Treinar Modelo", variant="primary", visible=False)
+        
+        def update_after_load():
+            message = predictor.load_data()
+            info = get_dataset_info()
+            features = predictor.get_numeric_features()
             
             # Criar checkboxes
-            feature_checkboxes = create_feature_checkboxes()
+            feature_checkboxes = []
+            if features and predictor.df is not None:
+                correlations = predictor.df.corr()['price'].abs().sort_values(ascending=False)
+                top_features = []
+                for feature in correlations.index:
+                    if feature != 'price' and len(top_features) < 6:
+                        top_features.append(feature)
+                
+                for feature in features:
+                    corr_value = correlations.get(feature, 0)
+                    feature_checkboxes.append(
+                        gr.Checkbox(
+                            label=f"{feature} (corr: {corr_value:.3f})",
+                            value=feature in top_features
+                        )
+                    )
             
-        with gr.Column(scale=1):
-            gr.Markdown("### 📊 Features Selecionadas:")
-            selected_features_display = gr.Markdown()
-            train_btn = gr.Button("🚀 Treinar Modelo", variant="primary", size="lg")
-    
-    # Atualizar display quando checkboxes mudam
-    for checkbox in feature_checkboxes:
-        checkbox.change(
-            update_selected_features_display,
-            inputs=feature_checkboxes,
-            outputs=[selected_features_display, train_btn]
+            return message, info, gr.Column(feature_checkboxes), gr.update(visible=True)
+        
+        load_btn.click(
+            update_after_load,
+            outputs=[load_status, dataset_info, feature_selection, train_btn]
         )
-    
-    # Resultados do treinamento
-    train_output = gr.Markdown()
-    metrics_display = gr.JSON(label="Métricas Detalhadas", visible=False)
-    
-    # Seção de previsão (inicialmente oculta)
-    with gr.Column(visible=False) as prediction_section:
-        gr.Markdown("### 💰 2. Faça Previsões de Preço")
+
+    with gr.Tab("📊 Análise Exploratória"):
+        gr.Markdown("### Explore os Dados Reais do King County")
         
         with gr.Row():
             with gr.Column():
-                gr.Markdown("#### 🎯 Configure as Características do Imóvel")
-                prediction_inputs = gr.Column()
-                predict_btn = gr.Button("🎯 Calcular Preço", variant="primary", size="lg")
+                gr.Markdown("#### 📈 Distribuição de Preços Reais")
+                price_plot_btn = gr.Button("🎨 Gerar Gráfico de Preços", variant="primary")
+                price_plot = gr.Plot()
             
             with gr.Column():
-                gr.Markdown("#### 📊 Resultado da Previsão")
-                prediction_output = gr.Markdown("Preencha os valores e clique em 'Calcular Preço'")
-                price_result = gr.Number(
-                    label="💵 Preço Previsto", 
-                    visible=False,
-                    elem_classes="price-display"
+                gr.Markdown("#### 🔗 Correlações entre Variáveis")
+                correlation_btn = gr.Button("🔄 Gerar Matriz de Correlação", variant="primary")
+                correlation_plot = gr.Plot()
+        
+        gr.Markdown("---")
+        gr.Markdown("#### 🔍 Análise Detalhada por Feature")
+        
+        with gr.Row():
+            with gr.Column():
+                feature_selector = gr.Dropdown(
+                    label="Selecione uma característica para análise detalhada",
+                    choices=initial_features,
+                    value=initial_features[0] if initial_features else None
                 )
+                feature_stats = gr.Markdown()
+            
+            with gr.Column():
+                feature_analysis_btn = gr.Button("📈 Analisar Feature", variant="primary")
+        
+        with gr.Row():
+            feature_dist_plot = gr.Plot(label="Distribuição da Feature")
+            feature_price_plot = gr.Plot(label="Relação com Preço")
+        
+        # Eventos
+        price_plot_btn.click(create_price_distribution_plot, outputs=[price_plot])
+        correlation_btn.click(create_correlation_plot, outputs=[correlation_plot])
+        feature_analysis_btn.click(
+            create_feature_analysis_plot,
+            inputs=[feature_selector],
+            outputs=[feature_dist_plot, feature_price_plot]
+        )
+        
+        # Inicializar estatísticas da primeira feature
+        if initial_features:
+            feature_stats.value = get_feature_stats(initial_features[0])
+        
+        # Atualizar estatísticas quando feature mudar
+        feature_selector.change(
+            get_feature_stats,
+            inputs=[feature_selector],
+            outputs=[feature_stats]
+        )
+
+    with gr.Tab("🤖 Treinar Modelo"):
+        gr.Markdown("### Treine o Modelo com Dados Reais")
+        
+        gr.Markdown("""
+        **🎯 Como Funciona:**
+        - Selecione as características para prever preços
+        - Features com alta correlação são melhores preditoras
+        - Modelo: **Regressão Linear** com dados reais
+        - **Dataset**: kc_house_data.csv (dados reais)
+        """)
+        
+        train_output = gr.Markdown("Selecione as features e clique em 'Treinar Modelo'")
+        metrics_display = gr.JSON(label="Métricas Detalhadas", visible=False)
+        
+        train_btn.click(
+            train_model_action,
+            inputs=[feature_selection],
+            outputs=[train_output, metrics_display, metrics_display]
+        )
+
+    with gr.Tab("💰 Fazer Previsão"):
+        gr.Markdown("### Faça Previsões com o Modelo Treinado")
+        
+        prediction_inputs = gr.Column()
+        predict_btn = gr.Button("🎯 Calcular Preço do Imóvel", variant="primary", size="lg")
+        
+        with gr.Row():
+            prediction_output = gr.Markdown("Preencha os valores e clique em 'Calcular Preço'")
+            price_result = gr.Number(
+                label="💵 Preço Previsto",
+                visible=False
+            )
+        
+        # Atualizar inputs quando modelo for treinado
+        metrics_display.change(
+            create_prediction_inputs,
+            inputs=[metrics_display],
+            outputs=[prediction_inputs]
+        )
+        
+        predict_btn.click(
+            predict_price_action,
+            inputs=[prediction_inputs],
+            outputs=[prediction_output, price_result]
+        ).then(
+            lambda: gr.update(visible=True),
+            outputs=[price_result]
+        )
     
-    # Eventos
-    train_btn.click(
-        train_model_action,
-        inputs=feature_checkboxes,
-        outputs=[train_output, metrics_display, metrics_display, prediction_section]
-    )
-    
-    metrics_display.change(
-        create_prediction_inputs,
-        inputs=[metrics_display],
-        outputs=[prediction_inputs]
-    )
-    
-    predict_btn.click(
-        predict_price_action,
-        inputs=[prediction_inputs],
-        outputs=[prediction_output, price_result]
-    ).then(
-        lambda: gr.update(visible=True),
-        outputs=[price_result]
-    )
+    with gr.Tab("📚 Explicações"):
+        gr.Markdown(
+            """
+            ## 📊 Guia do Dataset Real King County
+            
+            ### 🏠 Sobre os Dados Reais
+            **King County** inclui Seattle e áreas metropolitanas. O dataset contém:
+            - **Vendas reais** de imóveis
+            - **Período**: Maio 2014 - Maio 2015
+            - **Características**: 21 colunas incluindo localização, tamanho, qualidade
+            - **Preços**: Variam de dezenas de milhares a milhões de dólares
+            
+            ### 📈 Variáveis Principais:
+            - **price**: Preço de venda (target)
+            - **sqft_living**: Área habitável (pés quadrados)
+            - **bedrooms**: Número de quartos
+            - **bathrooms**: Número de banheiros
+            - **floors**: Número de andares
+            - **waterfront**: Vista para água (0/1)
+            - **view**: Qualidade da vista (0-4)
+            - **condition**: Condição do imóvel (1-5)
+            - **grade**: Grau de construção (1-13)
+            - **yr_built**: Ano de construção
+            - **lat/long**: Coordenadas geográficas
+            
+            ### 🎯 Interpretação dos Gráficos
+            
+            #### Distribuição de Preços
+            - Mostra a realidade do mercado imobiliário
+            - Geralmente assimétrica positiva (mais imóveis baratos)
+            - Presença de outliers (imóveis de luxo)
+            
+            #### Matriz de Correlação
+            - Baseada em **dados reais**
+            - Relações observadas no mercado real
+            - Padrões que o modelo aprenderá
+            
+            #### Análise por Feature
+            - Distribuições reais das características
+            - Relações observadas com preços de venda
+            - Insights do mercado real
+            
+            ### 🤖 Modelo de Machine Learning
+            - **Algoritmo**: Regressão Linear Múltipla
+            - **Base**: Dados reais de vendas
+            - **Aplicação**: Previsão de preços baseada em padrões históricos
+            
+            ### 💡 Insights do Mercado Real
+            - Features como **sqft_living** e **grade** têm alta correlação
+            - Localização (**lat/long**) é crucial para preços
+            - Características de qualidade impactam significativamente
+            - O modelo captura relações observadas no mercado real
+            """
+        )
 
 if __name__ == "__main__":
     demo.launch()