Update app.py

app.py

@@ -21,46 +21,41 @@ def generate_king_county_data(n_samples=2000):
     """Gera dados realísticos simulando o dataset King County"""
     np.random.seed(42)
     
-    # Gerar características básicas com relações realísticas
+    # Gerar características básicas
     sqft_living = np.random.normal(2080, 920, n_samples)
-    sqft_living = np.clip(sqft_living, 370, 13540)  # Valores reais do dataset
+    sqft_living = np.clip(sqft_living, 370, 13540)
     
-    bedrooms = np.random.choice([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], n_samples, p=[0.01, 0.05, 0.15, 0.3, 0.25, 0.15, 0.05, 0.02, 0.01, 0.01])
-    bathrooms = np.random.choice([0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5, 2.75, 3, 3.25, 3.5, 3.75, 4, 4.25, 4.5, 4.75, 5, 5.25, 5.5, 5.75, 6, 6.25, 6.5, 6.75, 7, 7.25, 7.5, 7.75, 8], 
-                               n_samples, p=[0.01, 0.02, 0.05, 0.08, 0.1, 0.12, 0.15, 0.1, 0.08, 0.06, 0.05, 0.04, 0.03, 0.02, 0.02, 0.01, 0.01, 0.01, 0.01, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005])
-    
-    floors = np.random.choice([1, 1.5, 2, 2.5, 3, 3.5], n_samples, p=[0.4, 0.25, 0.2, 0.1, 0.04, 0.01])
+    bedrooms = np.random.choice([1, 2, 3, 4, 5], n_samples, p=[0.1, 0.3, 0.4, 0.15, 0.05])
+    bathrooms = np.random.choice([1, 1.5, 2, 2.5, 3, 3.5], n_samples, p=[0.1, 0.2, 0.4, 0.2, 0.08, 0.02])
+    floors = np.random.choice([1, 1.5, 2, 2.5, 3], n_samples, p=[0.4, 0.3, 0.2, 0.08, 0.02])
     waterfront = np.random.choice([0, 1], n_samples, p=[0.99, 0.01])
     view = np.random.choice([0, 1, 2, 3, 4], n_samples, p=[0.9, 0.05, 0.03, 0.015, 0.005])
     condition = np.random.choice([1, 2, 3, 4, 5], n_samples, p=[0.05, 0.2, 0.5, 0.2, 0.05])
-    grade = np.random.choice([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], n_samples, p=[0.001, 0.005, 0.01, 0.05, 0.1, 0.15, 0.2, 0.15, 0.1, 0.08, 0.06, 0.03, 0.01])
+    grade = np.random.choice([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], n_samples, 
+                            p=[0.001, 0.005, 0.01, 0.05, 0.1, 0.15, 0.2, 0.15, 0.1, 0.08, 0.06, 0.03, 0.01])
     
-    # Ano de construção (de 1900 a 2015)
     yr_built = np.random.randint(1900, 2016, n_samples)
-    
-    # Localização (coordenadas de King County)
     lat = np.random.uniform(47.2, 47.8, n_samples)
     long = np.random.uniform(-122.5, -121.8, n_samples)
     
     # Calcular preço base com relações realísticas
     base_price = (
-        sqft_living * 300 +  # Preço por sqft
-        bedrooms * 50000 +   # Valor por quarto
-        bathrooms * 40000 +  # Valor por banheiro
-        floors * 25000 +     # Valor por andar
-        waterfront * 500000 + # Água frente
-        view * 25000 +       # Vista
-        condition * 15000 +  # Condição
-        grade * 30000 +      # Grau de qualidade
-        (2024 - yr_built) * -500 +  # Depreciação por ano
-        (lat - 47.5) * 100000 +  # Localização norte/sul
-        (long + 122.2) * 80000   # Localização leste/oeste
+        sqft_living * 300 +
+        bedrooms * 50000 +
+        bathrooms * 40000 +
+        floors * 25000 +
+        waterfront * 500000 +
+        view * 25000 +
+        condition * 15000 +
+        grade * 30000 +
+        (2024 - yr_built) * -500 +
+        (lat - 47.5) * 100000 +
+        (long + 122.2) * 80000
     )
     
-    # Adicionar variação aleatória
     noise = np.random.normal(0, 150000, n_samples)
     price = base_price + noise
-    price = np.clip(price, 75000, 5000000)  # Range realístico
+    price = np.clip(price, 75000, 5000000)
     
     # Criar DataFrame
     data = {
@@ -76,21 +71,17 @@ def generate_king_county_data(n_samples=2000):
         'yr_built': yr_built,
         'lat': lat,
         'long': long,
-        'sqft_lot': np.random.normal(15000, 10000, n_samples),  # Área do terreno
-        'sqft_above': sqft_living * 0.8,  # Área acima do solo
-        'sqft_basement': sqft_living * 0.2,  # Porão
-        'yr_renovated': np.where(np.random.random(n_samples) > 0.8, 
-                                np.random.randint(1950, 2016, n_samples), 0)  # Ano renovação
+        'sqft_lot': np.random.normal(15000, 10000, n_samples),
+        'sqft_above': sqft_living * 0.8,
+        'sqft_basement': sqft_living * 0.2,
     }
     
-    df = pd.DataFrame(data)
-    return df
+    return pd.DataFrame(data)
 
 class HousePricePredictor:
     def __init__(self):
         self.model = None
         self.scaler = None
-        self.feature_names = None
         self.df = None
         self.is_trained = False
         self.selected_features = None
@@ -123,7 +114,7 @@ class HousePricePredictor:
             
             self.selected_features = selected_features
             X = self.df[selected_features]
-            y = np.log1p(self.df['price'])  # Transformação logarítmica
+            y = np.log1p(self.df['price'])
             
             # Dividir dados
             X_train, X_test, y_train, y_test = train_test_split(
@@ -215,7 +206,7 @@ def load_data_action():
         # Calcular correlações com preço
         correlations = predictor.df.corr()['price'].abs().sort_values(ascending=False)
         
-        # Selecionar automaticamente as 6 features mais correlacionadas (excluindo price)
+        # Selecionar automaticamente as 6 features mais correlacionadas
         top_features = []
         for feature in correlations.index:
             if feature != 'price' and len(top_features) < 6:
@@ -226,8 +217,7 @@ def load_data_action():
             feature_checkboxes.append(
                 gr.Checkbox(
                     label=f"{feature} (corr: {corr_value:.3f})",
-                    value=feature in top_features,
-                    info=f"Média: {predictor.df[feature].mean():.1f}"
+                    value=feature in top_features
                 )
             )
     
@@ -272,15 +262,14 @@ def train_model_action(*checkbox_values):
         return result, None, gr.update(visible=False)
 
 def create_correlation_plot():
-    """Cria gráfico de correlação das features numéricas"""
+    """Cria gráfico de correlação"""
     if predictor.df is None:
         return None
     
     try:
-        # Selecionar apenas algumas features para não sobrecarregar o gráfico
+        # Selecionar features mais importantes
         numeric_cols = predictor.df.select_dtypes(include=[np.number]).columns.tolist()
-        if len(numeric_cols) > 8:  # Limitar para visualização
-            # Pegar as mais correlacionadas com price
+        if len(numeric_cols) > 8:
             correlations = predictor.df.corr()['price'].abs().sort_values(ascending=False)
             top_features = correlations.index[:8].tolist()
         else:
@@ -288,11 +277,10 @@ def create_correlation_plot():
         
         corr_matrix = predictor.df[top_features].corr()
         
-        fig, ax = plt.subplots(figsize=(12, 10))
+        fig, ax = plt.subplots(figsize=(10, 8))
         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 entre Variáveis\n(Valores próximos de 1 ou -1 indicam forte correlação)', 
-                    fontsize=14, fontweight='bold', pad=20)
+        ax.set_title('Matriz de Correlação', fontsize=14, fontweight='bold')
         plt.tight_layout()
         return fig
     except Exception as e:
@@ -305,58 +293,41 @@ def create_feature_analysis_plot(selected_feature):
         return None, None
     
     try:
-        # Gráfico 1: Distribuição da feature
-        fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
-        
-        # Histograma da distribuição
+        # Gráfico 1: Distribuição
+        fig1, ax1 = plt.subplots(figsize=(8, 4))
         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.axvline(predictor.df[selected_feature].mean(), color='red', linestyle='--', linewidth=2)
         ax1.set_xlabel(selected_feature)
         ax1.set_ylabel('Frequência')
-        ax1.set_title(f'📊 Distribuição de {selected_feature}')
-        ax1.legend()
+        ax1.set_title(f'Distribuição de {selected_feature}')
         ax1.grid(True, alpha=0.3)
-        
-        # Boxplot
-        ax2.boxplot(predictor.df[selected_feature])
-        ax2.set_ylabel(selected_feature)
-        ax2.set_title(f'📦 Boxplot - {selected_feature}')
-        ax2.grid(True, alpha=0.3)
-        
         plt.tight_layout()
         
         # Gráfico 2: Relação com preço
-        fig2, ax = plt.subplots(figsize=(10, 6))
+        fig2, ax2 = plt.subplots(figsize=(8, 4))
         
-        if predictor.df[selected_feature].nunique() < 10:  # Variável categórica
-            # Boxplot por categoria
+        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'])
             
-            ax.boxplot(data_to_plot, labels=categories)
-            ax.set_xlabel(selected_feature)
-            ax.set_ylabel('Preço ($)')
-            ax.set_title(f'💰 Preço vs {selected_feature}\n(Corr: {predictor.df[selected_feature].corr(predictor.df["price"]):.3f})')
-            
-        else:  # Variável contínua
-            # Scatter plot
-            ax.scatter(predictor.df[selected_feature], predictor.df['price'], alpha=0.5, s=20, color='steelblue')
-            ax.set_xlabel(selected_feature)
-            ax.set_ylabel('Preço ($)')
-            correlation = predictor.df[selected_feature].corr(predictor.df['price'])
-            ax.set_title(f'💰 Preço vs {selected_feature}\n(Corr: {correlation:.3f})')
-            
+            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.5, 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)
-            ax.plot(x_range, p(x_range), "r--", linewidth=2, alpha=0.8, label='Tendência')
-            ax.legend()
+            ax2.plot(x_range, p(x_range), "r--", linewidth=2, alpha=0.8)
         
-        ax.grid(True, alpha=0.3)
+        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)
         plt.tight_layout()
         
         return fig1, fig2
@@ -370,29 +341,17 @@ def create_price_distribution_plot():
     if predictor.df is None:
         return None
     
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
-    
-    # Histograma
-    ax1.hist(predictor.df['price'], bins=50, edgecolor='black', alpha=0.7, color='steelblue')
-    ax1.axvline(predictor.df['price'].mean(), color='red', linestyle='--', linewidth=2, 
+    fig, ax = plt.subplots(figsize=(10, 5))
+    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}')
-    ax1.axvline(predictor.df['price'].median(), color='green', linestyle='--', linewidth=2, 
+    ax.axvline(predictor.df['price'].median(), color='green', linestyle='--', linewidth=2, 
                label=f'Mediana: ${predictor.df["price"].median():,.0f}')
-    ax1.set_xlabel('Preço ($)')
-    ax1.set_ylabel('Número de Imóveis')
-    ax1.set_title('🏠 Distribuição dos Preços dos Imóveis')
-    ax1.legend()
-    ax1.grid(True, alpha=0.3)
-    
-    # Boxplot
-    ax2.boxplot(predictor.df['price'])
-    ax2.set_ylabel('Preço ($)')
-    ax2.set_title('📦 Distribuição - Boxplot')
-    ax2.grid(True, alpha=0.3)
-    
-    # Formatar eixos
-    ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x:,.0f}'))
-    
+    ax.set_xlabel('Preço ($)')
+    ax.set_ylabel('Número de Imóveis')
+    ax.set_title('Distribuição dos Preços dos Imóveis')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
     plt.tight_layout()
     return fig
 
@@ -405,27 +364,17 @@ def get_feature_stats(feature):
     correlation = predictor.df[feature].corr(predictor.df['price'])
     
     return f"""
-    ## 📈 Estatísticas de **{feature}**
-    
-    **Valores Básicos:**
+    **Estatísticas de {feature}:**
     - 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}
-    - Número de 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 com preço
+    - Correlação com Preço: {correlation:.3f}
     """
 
 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 []
     
@@ -436,21 +385,17 @@ def create_prediction_inputs(metrics_result):
             max_val = float(predictor.df[feature].max())
             mean_val = float(predictor.df[feature].mean())
             
-            # Definir step apropriado baseado no range
             step = (max_val - min_val) / 100
             if step < 0.1:
                 step = 0.1
-            elif step > 100:
-                step = 10
             
             inputs.append(
                 gr.Slider(
-                    label=f"🏠 {feature}",
+                    label=feature,
                     minimum=min_val,
                     maximum=max_val,
                     value=mean_val,
-                    step=step,
-                    info=f"Range: {min_val:.1f} - {max_val:.1f}"
+                    step=step
                 )
             )
     
@@ -459,36 +404,31 @@ def create_prediction_inputs(metrics_result):
 def predict_price_action(*feature_values):
     """Faz previsão de preço"""
     if not predictor.is_trained:
-        return "❌ Modelo não treinado. Por favor, treine o modelo primeiro.", None
+        return "❌ Modelo não treinado. Treine o modelo primeiro.", None
     
     try:
-        # Criar dicionário com os valores das features
         input_features = {}
         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 no modelo", None
+            return "❌ Nenhuma feature selecionada", None
         
         pred_price, error = predictor.predict_price(input_features)
         
         if error:
             return f"❌ {error}", None
         
-        # Criar resumo das características
         features_summary = "\n".join([f"- **{k}**: {v:.2f}" for k, v in input_features.items()])
         
         result_text = f"""
-        ## 🏠 Previsão de Preço do Imóvel
+        ## Previsão de Preço
         
-        ### 💰 **Preço Estimado: ${pred_price:,.2f}**
+        **💰 Preço Estimado: ${pred_price:,.2f}**
         
-        ### 📋 Características Informadas:
+        **Características:**
         {features_summary}
-        
-        ---
-        *💡 Nota: Esta é uma estimativa baseada no modelo de regressão linear treinado com dados de King County.*
         """
         
         return result_text, pred_price
@@ -497,72 +437,54 @@ def predict_price_action(*feature_values):
         return f"❌ Erro na previsão: {str(e)}", None
 
 # Interface Gradio
-with gr.Blocks(title="🏠 Análise e Previsão de Preços de Imóveis - King County") as demo:
+with gr.Blocks(title="Previsão de Preços de Imóveis") as demo:
     gr.Markdown(
         """
         # 🏠 Análise e Previsão de Preços de Imóveis
-        ## King County, Washington - USA
-        
-        ### 📊 Sobre os Dados:
-        Este aplicativo utiliza dados **realísticos** simulando o mercado imobiliário de King County (Seattle).
-        Os dados incluem características como área construída, quartos, banheiros, localização e muito mais.
-        
-        ### 🎯 Funcionalidades:
-        - **Análise Exploratória**: Gráficos interativos dos dados
-        - **Seleção de Features**: Escolha quais características usar no modelo
-        - **Treinamento**: Modelo de Machine Learning para prever preços
-        - **Previsão**: Estime o preço de um imóvel com características específicas
+        ## King County, Washington
         
+        Analise dados imobiliários e faça previsões de preços usando machine learning.
         """
     )
     
-    # Definir todas as variáveis da interface primeiro
-    with gr.Tab("🚀 1. Carregar Dados"):
-        gr.Markdown("### Primeiro Passo: Carregar os Dados")
-        load_btn = gr.Button("📂 Carregar Dados do King County", variant="primary", size="lg")
-        load_status = gr.Markdown("Clique no botão para carregar os dados de imóveis...")
-        feature_selection = gr.Column()
-        train_btn = gr.Button("🚀 Treinar Modelo de Previsão", variant="primary", size="lg", visible=False)
-        
-        load_btn.click(
-            load_data_action,
-            outputs=[load_status, feature_selection, train_btn]
-        )
+    # Carregar dados automaticamente ao iniciar
+    initial_message = predictor.load_data()
+    initial_features = predictor.get_numeric_features()
     
-    with gr.Tab("📈 2. Análise Exploratória"):
-        gr.Markdown("### Explore os Dados e Visualize Relações")
+    with gr.Tab("📊 Análise Exploratória"):
+        gr.Markdown("### Explore os Dados")
         
         with gr.Row():
             with gr.Column():
-                gr.Markdown("#### 📊 Distribuição de Preços")
-                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",
-                    choices=[],
-                    interactive=True
+                    label="Selecione uma feature",
+                    choices=initial_features,
+                    value=initial_features[0] if initial_features else None
                 )
-                feature_stats = gr.Markdown("Selecione uma feature acima...")
+                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()
         
-        # Conectar eventos
+        # 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(
@@ -570,23 +492,40 @@ with gr.Blocks(title="🏠 Análise e Previsão de Preços de Imóveis - King Co
             inputs=[feature_selector],
             outputs=[feature_dist_plot, feature_price_plot]
         )
-        feature_selector.change(
-            get_feature_stats,
-            inputs=[feature_selector],
-            outputs=[feature_stats]
-        )
+        
+        # Atualizar estatísticas quando feature mudar
+        def update_stats(feature):
+            return get_feature_stats(feature)
+        
+        feature_selector.change(update_stats, inputs=[feature_selector], outputs=[feature_stats])
     
-    with gr.Tab("🤖 3. Treinar Modelo"):
-        gr.Markdown("### Configure e Treine o Modelo de Previsão")
-        gr.Markdown("""
-        **🎯 Como Funciona:**
-        - Selecione as características que deseja usar para prever preços
-        - Features com alta correlação (próximas de 1 ou -1) geralmente são melhores preditoras
-        - O modelo usará Regressão Linear para aprender os padrões
-        """)
-        
-        train_output = gr.Markdown("Selecione as features acima e clique em 'Treinar Modelo'")
-        metrics_display = gr.JSON(label="Métricas Detalhadas", visible=False)
+    with gr.Tab("🤖 Treinar Modelo"):
+        gr.Markdown("### Treine o Modelo de Previsão")
+        
+        gr.Markdown(f"**Status:** {initial_message}")
+        gr.Markdown("Selecione as features para o modelo:")
+        
+        feature_checkboxes = []
+        if initial_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 initial_features:
+                corr_value = correlations.get(feature, 0)
+                feature_checkboxes.append(
+                    gr.Checkbox(
+                        label=f"{feature} (corr: {corr_value:.3f})",
+                        value=feature in top_features
+                    )
+                )
+        
+        feature_selection = gr.Column(feature_checkboxes)
+        train_btn = gr.Button("Treinar Modelo", variant="primary", size="lg")
+        train_output = gr.Markdown()
+        metrics_display = gr.JSON(visible=False)
         
         train_btn.click(
             train_model_action,
@@ -594,26 +533,19 @@ with gr.Blocks(title="🏠 Análise e Previsão de Preços de Imóveis - King Co
             outputs=[train_output, metrics_display, metrics_display]
         )
     
-    with gr.Tab("💰 4. Fazer Previsão"):
-        gr.Markdown("### Faça uma Previsão de Preço")
-        gr.Markdown("Ajuste os valores das características para estimar o preço de um imóvel:")
+    with gr.Tab("💰 Fazer Previsão"):
+        gr.Markdown("### Faça uma Previsão")
         
         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 acima e clique em 'Calcular Preço'")
-            price_result = gr.Number(
-                label="💵 Preço Previsto",
-                visible=False
-            )
+        predict_btn = gr.Button("Calcular Preço", variant="primary", size="lg")
+        prediction_output = gr.Markdown()
+        price_result = gr.Number(visible=False)
         
         # Atualizar inputs quando modelo for treinado
-        metrics_display.change(
-            create_prediction_inputs,
-            inputs=[metrics_display],
-            outputs=[prediction_inputs]
-        )
+        def update_prediction_inputs(metrics):
+            return create_prediction_inputs(metrics)
+        
+        metrics_display.change(update_prediction_inputs, inputs=[metrics_display], outputs=[prediction_inputs])
         
         predict_btn.click(
             predict_price_action,
@@ -624,71 +556,42 @@ with gr.Blocks(title="🏠 Análise e Previsão de Preços de Imóveis - King Co
             outputs=[price_result]
         )
     
-    with gr.Tab("📚 5. Explicações"):
+    with gr.Tab("📚 Explicações"):
         gr.Markdown(
             """
-            ## 📊 Guia Completo de Análise
-            
-            ### 🏠 Sobre os Dados
-            **King County** inclui Seattle e é um mercado imobiliário dinâmico. Os dados simulados incluem:
-            - **Preços**: De $75,000 a $5,000,000
-            - **Características**: Área, quartos, banheiros, localização, qualidade, etc.
-            - **Período**: Imóveis de 1900 até 2015
-            
-            ### 📈 Interpretação dos Gráficos
-            
-            #### 1. Distribuição de Preços
-            - **Histograma**: Mostra quantos imóveis existem em cada faixa de preço
-            - **Média vs Mediana**: Se a média > mediana, há imóveis muito caros puxando a média
-            - **Assimetria**: Mercados reais geralmente têm assimetria positiva (mais imóveis baratos)
-            
-            #### 2. Matriz de Correlação
-            - **🔴 Vermelho**: Correlação positiva (ex: área maior → preço maior)
-            - **🔵 Azul**: Correlação negativa (ex: ano mais antigo → preço menor)  
-            - **Valores**: -1 (perfeita negativa) a +1 (perfeita positiva)
-            - **Para modelo**: Busque features com |correlação| > 0.3 com preço
-            
-            #### 3. Análise por Feature
-            - **Distribuição**: Como os valores se espalham (normal, assimétrica)
-            - **Relação com Preço**: Padrão linear? Há outliers?
-            - **Boxplot**: Mostra mediana, quartis e valores extremos
-            
-            ### 🤖 Sobre o Modelo
-            - **Algoritmo**: Regressão Linear Múltipla
-            - **Transformação**: Logarítmica nos preços para normalizar
-            - **Avaliação**: R² mostra % da variância explicada (0-100%)
-            - **Coeficientes**: Impacto de cada feature no preço final
-            
-            ### 💡 Dicas para Boas Previsões
-            1. **Selecione features relevantes**: Área, quartos, localização
-            2. **Evite multicolinearidade**: Não use features muito correlacionadas entre si
-            3. **Verifique relações lineares**: Features com relação clara com preço funcionam melhor
-            4. **Considere o contexto**: Características únicas podem afetar preços reais
-            
-            ### 🎯 Métricas do Modelo
-            - **R²**: 0.7-0.9 = Excelente, 0.5-0.7 = Bom, <0.5 = Precisa melhorar
-            - **RMSE**: Erro médio em dólares (ideal: <20% do preço médio)
-            - **Coeficientes**: Mostram quanto cada feature impacta no preço
+            ## Guia de Uso
+            
+            ### 📊 Análise Exploratória
+            - **Distribuição de Preços**: Veja como os preços estão distribuídos
+            - **Matriz de Correlação**: Identifique relações entre variáveis
+            - **Análise por Feature**: Explore cada característica individualmente
+            
+            ### 🤖 Treinamento do Modelo
+            - Selecione features com alta correlação com preço
+            - O modelo usa Regressão Linear
+            - Métricas: R², RMSE, MAE
+            
+            ### 💰 Previsões
+            - Ajuste os valores das características
+            - Obtenha previsões de preço em tempo real
+            - Baseado no modelo treinado
+            
+            ### 📈 Interpretação
+            - **R²**: Proporção da variância explicada (0-1)
+            - **RMSE**: Erro médio em dólares
+            - **Correlação**: Força da relação entre variáveis (-1 a +1)
             """
         )
 
-# Inicializar dados quando o app carregar
-def initialize_app():
-    """Inicializa o aplicativo carregando dados"""
-    message = predictor.load_data()
-    features = predictor.get_numeric_features()
-    
-    # Retornar valores para atualizar a interface
-    return (
-        message, 
-        gr.update(choices=features, value=features[0] if features else None)
-    )
+# Inicializar estatísticas da primeira feature
+if initial_features:
+    initial_stats = get_feature_stats(initial_features[0])
+else:
+    initial_stats = "Nenhuma feature disponível"
 
-# Conectar a inicialização quando o app carregar
-demo.load(
-    initialize_app,
-    outputs=[load_status, feature_selector]
-)
+# Atualizar o componente de estatísticas
+if 'feature_stats' in locals():
+    feature_stats.value = initial_stats
 
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch()