Update app.py

app.py

@@ -250,7 +250,7 @@ def train_model_action(*checkbox_values):
             selected_features.append(features[i])
     
     if not selected_features:
-        return "❌ Nenhuma feature selecionada. Selecione pelo menos uma feature.", None, gr.update(visible=False)
+        return "❌ Nenhuma feature selecionada. Selecione pelo menos uma feature.", None, gr.update(visible=False), gr.update(visible=False)
     
     success, result = predictor.train_model(selected_features)
     
@@ -271,149 +271,17 @@ def train_model_action(*checkbox_values):
             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)
+        return metrics_text, result, gr.update(visible=True), gr.update(visible=True)
     else:
-        return result, None, gr.update(visible=False)
+        return result, None, gr.update(visible=False), 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(selected_features):
+def create_prediction_inputs(metrics_result):
     """Cria inputs para previsão baseado nas features selecionadas"""
-    if not selected_features:
+    if metrics_result is None or 'selected_features' not in metrics_result:
         return []
     
     inputs = []
-    for feature in selected_features:
+    for feature in metrics_result['selected_features']:
         if feature in predictor.df.columns:
             min_val = float(predictor.df[feature].min())
             max_val = float(predictor.df[feature].max())
@@ -438,16 +306,19 @@ def create_prediction_inputs(selected_features):
     
     return inputs
 
-def predict_price_action(*feature_values, selected_features):
+def predict_price_action(*feature_values):
     """Faz previsão de preço"""
     if not predictor.is_trained:
         return "❌ Modelo não treinado. Treine o modelo primeiro.", None
     
     try:
         input_features = {}
-        for i, feature in enumerate(selected_features):
-            if i < len(feature_values):
-                input_features[feature] = feature_values[i]
+        if hasattr(predictor, 'selected_features') and predictor.selected_features:
+            for i, feature in enumerate(predictor.selected_features):
+                if i < len(feature_values):
+                    input_features[feature] = feature_values[i]
+        else:
+            return "❌ Nenhuma feature selecionada", None
         
         pred_price, error = predictor.predict_price(input_features)
         
@@ -473,174 +344,82 @@ def predict_price_action(*feature_values, selected_features):
     except Exception as e:
         return f"❌ Erro na previsão: {str(e)}", None
 
-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 simplificada
-with gr.Blocks(title="🏠 Análise e Previsão - King County Dataset Real") as demo:
+# Interface Gradio simplificada com tudo em uma aba
+with gr.Blocks(title="🏠 Cálculo de Preç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
+        # 🏠 Cálculo de Preços de Imóveis - King County
+        ## 📊 Selecione Features, Treine Modelo e Faça Previsões
         """
     )
     
     # Status inicial
     initial_status = gr.Markdown(f"**Status:** {initial_message}")
-    dataset_info = gr.Markdown(get_dataset_info())
     
-    with gr.Tab("🤖 1. Treinar Modelo"):
-        gr.Markdown("### Selecione as Features e Treine o Modelo")
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                gr.Markdown("#### 📋 Selecione as Features:")
-                
-                # Criar checkboxes
-                feature_checkboxes = create_feature_checkboxes()
-                
-            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]
-            )
-        
-        # Resultados do treinamento
-        train_output = gr.Markdown()
-        metrics_display = gr.JSON(label="Métricas Detalhadas", visible=False)
-        
-        train_btn.click(
-            train_model_action,
-            inputs=feature_checkboxes,
-            outputs=[train_output, metrics_display, metrics_display]
-        )
-    
-    with gr.Tab("💰 2. Fazer Previsão"):
-        gr.Markdown("### Faça Previsões com o Modelo")
-        
-        gr.Markdown("#### 📋 Selecione as Features para Previsão:")
-        
-        # Checkboxes separadas para previsão
-        prediction_feature_checkboxes = create_feature_checkboxes()
-        
-        # Display das features selecionadas para previsão
-        prediction_selected_display = gr.Markdown()
-        
-        # Inputs dinâmicos para previsão
-        prediction_inputs = gr.Column()
-        
-        # Botão de previsão
-        predict_btn = gr.Button("🎯 Calcular Preço", variant="primary")
-        
-        # Resultado da previsão
-        with gr.Row():
-            prediction_output = gr.Markdown("Selecione as features e ajuste os valores")
-            price_result = gr.Number(label="💵 Preço Previsto", visible=False)
-        
-        # Função para atualizar inputs quando features mudam
-        def update_prediction_inputs(*checkbox_values):
-            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])
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown("### 📋 1. Selecione as Features para o Modelo")
             
-            # Atualizar display
-            if selected:
-                display_text = "**Features selecionadas para previsão:**\n" + "\n".join([f"• {feat}" for feat in selected])
-                display_text += f"\n\n**Total:** {len(selected)} features"
-            else:
-                display_text = "❌ Nenhuma feature selecionada"
+            # Criar checkboxes
+            feature_checkboxes = create_feature_checkboxes()
             
-            # Criar inputs
-            inputs = create_prediction_inputs(selected)
-            
-            return display_text, inputs
-        
-        # Conectar checkboxes de previsão
-        for checkbox in prediction_feature_checkboxes:
-            checkbox.change(
-                update_prediction_inputs,
-                inputs=prediction_feature_checkboxes,
-                outputs=[prediction_selected_display, prediction_inputs]
-            )
-        
-        # Fazer previsão
-        predict_btn.click(
-            lambda *vals: predict_price_action(*vals, selected_features=[f for i, f in enumerate(predictor.get_numeric_features()) if i < len(prediction_feature_checkboxes) and prediction_feature_checkboxes[i].value]),
-            inputs=[prediction_inputs],
-            outputs=[prediction_output, price_result]
-        ).then(
-            lambda: gr.update(visible=True),
-            outputs=[price_result]
+        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]
         )
     
-    with gr.Tab("📊 3. Análise Exploratória"):
-        gr.Markdown("### Explore os Dados")
+    # 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.Row():
             with gr.Column():
-                gr.Markdown("#### 📈 Distribuição de Preços")
-                price_plot_btn = gr.Button("🎨 Gerar Gráfico", variant="primary")
-                price_plot = gr.Plot()
+                gr.Markdown("#### 🎯 Configure as Características do Imóvel")
+                prediction_inputs = gr.Column()
+                predict_btn = gr.Button("🎯 Calcular Preço", variant="primary", size="lg")
             
             with gr.Column():
-                gr.Markdown("#### 🔗 Correlações")
-                correlation_btn = gr.Button("🔄 Gerar Matriz", variant="primary")
-                correlation_plot = gr.Plot()
-        
-        gr.Markdown("#### 🔍 Análise por Feature")
-        
-        with gr.Row():
-            with gr.Column():
-                feature_selector = gr.Dropdown(
-                    label="Selecione uma feature",
-                    choices=initial_features,
-                    value=initial_features[0] if initial_features else None
+                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"
                 )
-                feature_stats = gr.Markdown()
-            
-            with gr.Column():
-                feature_analysis_btn = gr.Button("📈 Analisar", variant="primary")
-        
-        with gr.Row():
-            feature_dist_plot = gr.Plot()
-            feature_price_plot = gr.Plot()
-        
-        # 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
-        if initial_features:
-            feature_stats.value = get_feature_stats(initial_features[0])
-        
-        feature_selector.change(
-            get_feature_stats,
-            inputs=[feature_selector],
-            outputs=[feature_stats]
-        )
+    
+    # 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]
+    )
 
 if __name__ == "__main__":
     demo.launch()