Update app.py

app.py

@@ -22,14 +22,13 @@ class HousePricePredictor:
         self.scaler = None
         self.df = None
         self.is_trained = False
-        self.selected_features = None
+        self.selected_features = []
         self._data_loaded = False
         self.stats = {
             'n_imoveis': 0,
             'n_caracteristicas': 0,
             'preco_medio': 0
         }
-        self.feature_states = {}  # Para armazenar estado das features
         
     def load_data(self):
         """Carrega dados do arquivo kc_house_data.csv"""
@@ -43,9 +42,6 @@ class HousePricePredictor:
                 # Limpeza básica dos dados
                 self._clean_data()
                 
-                # Inicializar estados das features
-                self._initialize_feature_states()
-                
                 # Atualizar estatísticas
                 self.stats = {
                     'n_imoveis': self.df.shape[0],
@@ -82,21 +78,6 @@ class HousePricePredictor:
         print(f"📊 Dados limpos: {self.df.shape[0]} imóveis")
         print(f"💰 Preço médio: ${self.df['price'].mean():,.2f}")
     
-    def _initialize_feature_states(self):
-        """Inicializa os estados das features baseado nas correlações"""
-        if self.df is not None:
-            correlations = self.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)
-            
-            # Inicializar estados
-            for feature in self.get_numeric_features():
-                self.feature_states[feature] = feature in top_features
-    
     def get_numeric_features(self):
         """Retorna lista de features numéricas (excluindo price)"""
         if self.df is None:
@@ -106,19 +87,16 @@ class HousePricePredictor:
             numeric_features.remove('price')
         return numeric_features
     
-    def get_feature_states(self):
-        """Retorna o estado atual das features"""
-        return self.feature_states.copy()
-    
-    def update_feature_states(self, feature_updates):
-        """Atualiza os estados das features"""
-        for feature, is_selected in feature_updates.items():
-            if feature in self.feature_states:
-                self.feature_states[feature] = is_selected
-    
-    def get_selected_features(self):
-        """Retorna lista de features selecionadas"""
-        return [feature for feature, selected in self.feature_states.items() if selected]
+    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"""
@@ -135,14 +113,12 @@ class HousePricePredictor:
                 'preco_medio': 0
             }
     
-    def train_model(self):
+    def train_model(self, selected_features):
         """Treina o modelo com as features selecionadas"""
         try:
             if self.df is None:
                 return False, "❌ Dados não carregados"
             
-            selected_features = self.get_selected_features()
-            
             if not selected_features:
                 return False, "❌ Selecione pelo menos uma feature"
             
@@ -234,21 +210,21 @@ 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 baseado no estado atual"""
+def create_feature_checkboxes(selected_features=None):
+    """Cria os checkboxes de features"""
     features = predictor.get_numeric_features()
     checkboxes = []
     
     if features and predictor.df is not None:
         correlations = predictor.df.corr()['price'].abs().sort_values(ascending=False)
-        feature_states = predictor.get_feature_states()
         
         for feature in features:
             corr_value = correlations.get(feature, 0)
-            is_selected = feature_states.get(feature, False)
+            is_selected = feature in (selected_features or [])
             
             checkboxes.append(
                 gr.Checkbox(
@@ -260,79 +236,67 @@ def create_feature_checkboxes():
     
     return checkboxes
 
-def update_feature_selection(*checkbox_values):
-    """Atualiza a seleção de features quando checkboxes mudam"""
-    features = predictor.get_numeric_features()
-    feature_updates = {}
-    
-    for i, is_checked in enumerate(checkbox_values):
-        if i < len(features):
-            feature_updates[features[i]] = is_checked
-    
-    predictor.update_feature_states(feature_updates)
-    
-    # Retorna o texto com as features selecionadas
-    selected_features = predictor.get_selected_features()
+def update_selected_features_display(selected_features):
+    """Atualiza o display das features selecionadas"""
     if selected_features:
         features_text = "**Features selecionadas:**\n" + "\n".join([f"• {feat}" for feat in selected_features])
         features_text += f"\n\n**Total:** {len(selected_features)} features"
+        return features_text, gr.update(visible=bool(selected_features))
     else:
-        features_text = "❌ Nenhuma feature selecionada"
-    
-    return features_text
+        return "❌ Nenhuma feature selecionada", gr.update(visible=False)
 
-def select_all_features():
+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])
+    return selected
+
+def select_all_features(feature_checkboxes):
     """Seleciona todas as features"""
     features = predictor.get_numeric_features()
-    for feature in features:
-        predictor.feature_states[feature] = True
-    
-    # Recriar checkboxes
-    checkboxes = create_feature_checkboxes()
-    features_text = "**Todas as features selecionadas**\n" + "\n".join([f"• {feat}" for feat in features])
-    features_text += f"\n\n**Total:** {len(features)} features"
-    
-    return checkboxes, features_text
+    # Atualizar todos os checkboxes para True
+    updated_checkboxes = [gr.Checkbox(value=True) for _ in feature_checkboxes]
+    return updated_checkboxes, *update_selected_features_display(features)
 
-def deselect_all_features():
+def deselect_all_features(feature_checkboxes):
     """Desseleciona todas as features"""
-    features = predictor.get_numeric_features()
-    for feature in features:
-        predictor.feature_states[feature] = False
-    
-    # Recriar checkboxes
-    checkboxes = create_feature_checkboxes()
-    return checkboxes, "❌ Nenhuma feature selecionada"
+    # Atualizar todos os checkboxes para False
+    updated_checkboxes = [gr.Checkbox(value=False) for _ in feature_checkboxes]
+    return updated_checkboxes, *update_selected_features_display([])
 
-def select_top_features():
+def select_top_features(feature_checkboxes):
     """Seleciona apenas as top 6 features por correlação"""
+    top_features = predictor.get_top_features_by_correlation(6)
     features = predictor.get_numeric_features()
-    if 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)
-        
-        # Resetar todos para False
-        for feature in features:
-            predictor.feature_states[feature] = False
-        
-        # Selecionar apenas as top features
-        for feature in top_features:
-            if feature in predictor.feature_states:
-                predictor.feature_states[feature] = True
     
-    # Recriar checkboxes
-    checkboxes = create_feature_checkboxes()
-    features_text = "**Top 6 features selecionadas:**\n" + "\n".join([f"• {feat}" for feat in top_features])
-    features_text += f"\n\n**Total:** {len(top_features)} features"
+    # Atualizar checkboxes baseado nas top features
+    updated_checkboxes = []
+    for i, feature in enumerate(features):
+        is_selected = feature in top_features
+        updated_checkboxes.append(gr.Checkbox(value=is_selected))
     
-    return checkboxes, features_text
+    return updated_checkboxes, *update_selected_features_display(top_features)
 
-def train_model_action():
+def train_model_action(selected_features_text):
     """Treina o modelo com features selecionadas"""
-    success, result = predictor.train_model()
+    # Extrair features selecionadas do texto de display
+    if "❌" in selected_features_text:
+        return "❌ Nenhuma feature selecionada. Selecione features na aba anterior.", None, gr.update(visible=False)
+    
+    # Obter features selecionadas dos checkboxes atuais
+    features = predictor.get_numeric_features()
+    selected_features = []
+    for feature in features:
+        if f"• {feature}" in selected_features_text:
+            selected_features.append(feature)
+    
+    if not selected_features:
+        return "❌ Nenhuma feature selecionada. Selecione features na aba anterior.", None, gr.update(visible=False)
+    
+    success, result = predictor.train_model(selected_features)
     
     if success:
         metrics_text = f"""
@@ -355,6 +319,8 @@ def train_model_action():
     else:
         return result, None, gr.update(visible=False)
 
+# ... (mantenha as outras funções como create_correlation_plot, create_feature_analysis_plot, etc. inalteradas)
+
 def create_correlation_plot():
     """Cria gráfico de correlação"""
     if predictor.df is None:
@@ -567,24 +533,12 @@ def get_dataset_info():
     - **Preço Médio**: ${stats['preco_medio']:,.2f}
     """
 
-def get_current_selection():
-    """Retorna a seleção atual de features"""
-    selected = predictor.get_selected_features()
-    if selected:
-        return f"**Features selecionadas para treinamento:**\n" + "\n".join([f"• {feat}" for feat in selected]) + f"\n\n**Total:** {len(selected)} features"
-    else:
-        return "❌ Nenhuma feature selecionada. Volte para a aba '1. Selecionar Features'."
-
-# Interface Gradio
+# Interface Gradio simplificada
 with gr.Blocks(title="🏠 Análise e Previsão - King County Dataset Real") as demo:
     gr.Markdown(
         """
         # 🏠 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.
         """
     )
     
@@ -592,94 +546,109 @@ with gr.Blocks(title="🏠 Análise e Previsão - King County Dataset Real") as
     initial_status = gr.Markdown(f"**Status:** {initial_message}")
     dataset_info = gr.Markdown(get_dataset_info())
     
+    # Estado para armazenar features selecionadas
+    selected_features_state = gr.State(value=[])
+    
     with gr.Tab("🤖 1. Selecionar Features"):
         gr.Markdown("### Selecione as Features para o Modelo")
         
-        gr.Markdown("""
-        **🎯 Como escolher:**
-        - **Features com alta correlação** (valores próximos de 1 ou -1) são melhores preditoras
-        - **Selecione múltiplas features** - quanto mais relevantes, melhor o modelo
-        - **Evite features muito correlacionadas** entre si
-        """)
-        
         with gr.Row():
             with gr.Column(scale=2):
                 # Botões de seleção em massa
                 with gr.Row():
-                    select_all_btn = gr.Button("✅ Selecionar Todas", variant="secondary", size="sm")
-                    deselect_all_btn = gr.Button("❌ Limpar Seleção", variant="secondary", size="sm")
-                    select_top_btn = gr.Button("🎯 Top 6 Features", variant="primary", size="sm")
+                    select_all_btn = gr.Button("✅ Selecionar Todas", variant="secondary")
+                    deselect_all_btn = gr.Button("❌ Limpar Seleção", variant="secondary")
+                    select_top_btn = gr.Button("🎯 Top 6 Features", variant="primary")
                 
                 # Checkboxes das features
-                feature_checkboxes = create_feature_checkboxes()
-                feature_container = gr.Column(feature_checkboxes)
+                initial_checkboxes = create_feature_checkboxes(top_features)
+                feature_checkboxes = []
+                for checkbox in initial_checkboxes:
+                    feature_checkboxes.append(checkbox)
                 
             with gr.Column(scale=1):
                 gr.Markdown("### 📋 Features Selecionadas")
-                selected_features_display = gr.Markdown("❌ Nenhuma feature selecionada")
-        
-        # Botão para treinar
-        train_btn = gr.Button("🚀 Treinar Modelo com Features Selecionadas", variant="primary", size="lg")
-        
-        # Atualizar display quando checkboxes mudam
-        def update_display(*args):
-            return update_feature_selection(*args)
-        
-        for checkbox in feature_checkboxes:
+                selected_features_display = gr.Markdown()
+                train_btn = gr.Button("🚀 Treinar Modelo", variant="primary", size="lg", visible=False)
+        
+        # Inicializar display
+        selected_features_display.value = update_selected_features_display(top_features)[0]
+        train_btn.visible = True
+        
+        # Função para atualizar quando checkboxes mudam
+        def on_checkbox_change(*checkbox_values):
+            selected = get_selected_features_from_checkboxes(*checkbox_values)
+            selected_features_state.value = selected
+            display_text, btn_visible = update_selected_features_display(selected)
+            return display_text, gr.update(visible=btn_visible)
+        
+        # Conectar eventos dos checkboxes
+        for i, checkbox in enumerate(feature_checkboxes):
             checkbox.change(
-                update_display,
+                on_checkbox_change,
                 inputs=feature_checkboxes,
-                outputs=[selected_features_display]
+                outputs=[selected_features_display, train_btn]
             )
         
         # Botões de seleção em massa
         select_all_btn.click(
-            select_all_features,
-            outputs=[feature_container, selected_features_display]
+            lambda: select_all_features(feature_checkboxes),
+            outputs=feature_checkboxes + [selected_features_display, train_btn]
         )
         
         deselect_all_btn.click(
-            deselect_all_features,
-            outputs=[feature_container, selected_features_display]
+            lambda: deselect_all_features(feature_checkboxes),
+            outputs=feature_checkboxes + [selected_features_display, train_btn]
         )
         
         select_top_btn.click(
-            select_top_features,
-            outputs=[feature_container, selected_features_display]
+            lambda: select_top_features(feature_checkboxes),
+            outputs=feature_checkboxes + [selected_features_display, train_btn]
         )
-
-    with gr.Tab("📊 2. Análise Exploratória"):
-        gr.Markdown("### Explore os Dados Reais do King County")
+    
+    with gr.Tab("🎯 2. Treinar Modelo"):
+        gr.Markdown("### Treine o Modelo")
+        
+        train_output = gr.Markdown("Selecione features na aba anterior e clique em 'Treinar Modelo'")
+        metrics_display = gr.JSON(label="Métricas Detalhadas", visible=False)
+        
+        train_btn.click(
+            lambda text: train_model_action(text),
+            inputs=[selected_features_display],
+            outputs=[train_output, metrics_display, metrics_display]
+        )
+    
+    with gr.Tab("📊 3. Análise Exploratória"):
+        gr.Markdown("### Explore os Dados")
         
         with gr.Row():
             with gr.Column():
-                gr.Markdown("#### 📈 Distribuição de Preços Reais")
-                price_plot_btn = gr.Button("🎨 Gerar Gráfico de Preços", variant="primary")
+                gr.Markdown("#### 📈 Distribuição de Preços")
+                price_plot_btn = gr.Button("🎨 Gerar Gráfico", variant="primary")
                 price_plot = gr.Plot()
             
             with gr.Column():
-                gr.Markdown("#### 🔗 Correlações entre Variáveis")
-                correlation_btn = gr.Button("🔄 Gerar Matriz de Correlação", variant="primary")
+                gr.Markdown("#### 🔗 Correlações")
+                correlation_btn = gr.Button("🔄 Gerar Matriz", variant="primary")
                 correlation_plot = gr.Plot()
         
-        gr.Markdown("---")
-        gr.Markdown("#### 🔍 Análise Detalhada por Feature")
+        gr.Markdown("#### 🔍 Análise por Feature")
         
         with gr.Row():
             with gr.Column():
                 feature_selector = gr.Dropdown(
-                    label="Selecione uma característica para análise detalhada",
+                    label="Selecione uma feature",
                     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")
+                feature_analysis_btn = gr.Button("📈 Analisar", 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")
+            feature_dist_plot = gr.Plot()
+            feature_price_plot = gr.Plot()
         
         # Eventos
         price_plot_btn.click(create_price_distribution_plot, outputs=[price_plot])
@@ -690,49 +659,26 @@ with gr.Blocks(title="🏠 Análise e Previsão - King County Dataset Real") as
             outputs=[feature_dist_plot, feature_price_plot]
         )
         
-        # Inicializar estatísticas da primeira feature
+        # Inicializar estatísticas
         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("🎯 3. Treinar Modelo"):
-        gr.Markdown("### Treine o Modelo com as Features Selecionadas")
-        
-        gr.Markdown("""
-        **📋 Features que serão usadas no modelo:**
-        (Selecione na aba "1. Selecionar Features")
-        """)
-        
-        current_selection_display = gr.Markdown(get_current_selection())
-        
-        train_output = gr.Markdown("Clique em 'Treinar Modelo' para iniciar o treinamento")
-        metrics_display = gr.JSON(label="Métricas Detalhadas", visible=False)
-        
-        train_btn.click(
-            lambda: [get_current_selection(), train_model_action()],
-            outputs=[current_selection_display, train_output, metrics_display, metrics_display]
-        )
-
+    
     with gr.Tab("💰 4. Fazer Previsão"):
-        gr.Markdown("### Faça Previsões com o Modelo Treinado")
+        gr.Markdown("### Faça Previsões")
         
         prediction_inputs = gr.Column()
-        predict_btn = gr.Button("🎯 Calcular Preço do Imóvel", variant="primary", size="lg")
+        predict_btn = gr.Button("🎯 Calcular Preço", variant="primary")
         
         with gr.Row():
-            prediction_output = gr.Markdown("Treine o modelo primeiro para fazer previsões")
-            price_result = gr.Number(
-                label="💵 Preço Previsto",
-                visible=False
-            )
+            prediction_output = gr.Markdown("Treine o modelo primeiro")
+            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],
@@ -747,46 +693,6 @@ with gr.Blocks(title="🏠 Análise e Previsão - King County Dataset Real") as
             lambda: gr.update(visible=True),
             outputs=[price_result]
         )
-    
-    with gr.Tab("📚 5. 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
-            
-            ### 🎯 Como Selecionar Features:
-            1. **Selecione múltiplas features** - Quanto mais características relevantes, melhor
-            2. **Priorize alta correlação** - Features com corr > 0.3 são boas preditoras
-            3. **Use botões de seleção em massa** - "Selecionar Todas", "Top 6 Features"
-            4. **Evite multicolinearidade** - Não selecione features muito correlacionadas entre si
-            
-            ### 📈 Features Mais Importantes:
-            - **sqft_living**: Área habitável (alta correlação)
-            - **grade**: Grau de qualidade da construção
-            - **lat/long**: Localização geográfica
-            - **waterfront**: Vista para água
-            - **view**: Qualidade da vista
-            - **sqft_above**: Área acima do solo
-            
-            ### 🤖 Sobre o Modelo:
-            - **Regressão Linear Múltipla** com transformação logarítmica
-            - **Treinamento**: 80% dos dados
-            - **Teste**: 20% dos dados
-            - **Avaliação**: R², RMSE, MAE
-            
-            ### 💡 Dicas:
-            - Comece com **Top 6 Features** para um modelo balanceado
-            - Experimente diferentes combinações de features
-            - Verifique as métricas para avaliar performance
-            - Use a aba de análise para entender cada feature
-            """
-        )
 
 if __name__ == "__main__":
     demo.launch()