Update app.py

app.py

@@ -16,35 +16,75 @@ sns.set_style("whitegrid")
 plt.rcParams['figure.figsize'] = (12, 6)
 plt.rcParams['font.size'] = 10
 
-# Carregar dados diretamente (sem upload)
-def load_sample_data():
-    """Carrega dados de exemplo ou do arquivo local"""
-    try:
-        # Tenta carregar de uma URL ou arquivo local
-        url = "https://raw.githubusercontent.com/guipsamora/pandas_exercises/master/04_Apply/Students_Alcohol_Consumption/student-mat.csv"
-        # Para o Hugging Face, vamos usar dados de exemplo se não encontrar o arquivo
-        df = pd.read_csv('kc_house_data.csv')
-        return df
-    except:
-        # Dados de exemplo se o arquivo não existir
-        print("Arquivo não encontrado, usando dados de exemplo...")
-        np.random.seed(42)
-        n_samples = 1000
-        data = {
-            'price': np.random.normal(500000, 200000, n_samples),
-            'sqft_living': np.random.normal(2000, 800, n_samples),
-            'bedrooms': np.random.randint(1, 6, n_samples),
-            'bathrooms': np.random.uniform(1, 4, n_samples),
-            'floors': np.random.choice([1, 1.5, 2, 2.5, 3], n_samples),
-            'waterfront': np.random.choice([0, 1], n_samples, p=[0.95, 0.05]),
-            'view': np.random.randint(0, 5, n_samples),
-            'condition': np.random.randint(1, 6, n_samples),
-            'grade': np.random.randint(1, 14, n_samples),
-            'yr_built': np.random.randint(1900, 2015, n_samples),
-            'lat': np.random.uniform(47.2, 47.8, n_samples),
-            'long': np.random.uniform(-122.5, -121.8, n_samples)
-        }
-        return pd.DataFrame(data)
+# Gerar dados realísticos do King County
+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
+    sqft_living = np.random.normal(2080, 920, n_samples)
+    sqft_living = np.clip(sqft_living, 370, 13540)  # Valores reais do dataset
+    
+    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])
+    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])
+    
+    # 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
+    )
+    
+    # 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
+    
+    # Criar DataFrame
+    data = {
+        'price': price,
+        'sqft_living': sqft_living,
+        'bedrooms': bedrooms,
+        'bathrooms': bathrooms,
+        'floors': floors,
+        'waterfront': waterfront,
+        'view': view,
+        'condition': condition,
+        'grade': grade,
+        '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
+    }
+    
+    df = pd.DataFrame(data)
+    return df
 
 class HousePricePredictor:
     def __init__(self):
@@ -56,17 +96,12 @@ class HousePricePredictor:
         self.selected_features = None
         
     def load_data(self):
-        """Carrega os dados"""
-        self.df = load_sample_data()
-        # Remover colunas não numéricas e ID se existirem
-        non_numeric_cols = self.df.select_dtypes(exclude=[np.number]).columns
-        if len(non_numeric_cols) > 0:
-            self.df = self.df.drop(columns=non_numeric_cols)
-        
-        if 'id' in self.df.columns:
-            self.df = self.df.drop(columns=['id'])
-            
-        return f"✅ Dados carregados: {self.df.shape[0]} linhas × {self.df.shape[1]} colunas"
+        """Carrega dados gerados"""
+        try:
+            self.df = generate_king_county_data()
+            return f"✅ Dados carregados: {self.df.shape[0]} imóveis × {self.df.shape[1]} características"
+        except Exception as e:
+            return f"❌ Erro ao carregar dados: {str(e)}"
     
     def get_numeric_features(self):
         """Retorna lista de features numéricas (excluindo price)"""
@@ -174,106 +209,160 @@ def load_data_action():
     message = predictor.load_data()
     features = predictor.get_numeric_features()
     
+    # Criar checkboxes para features
     feature_checkboxes = []
-    if features:
-        # Selecionar automaticamente as 5 features mais correlacionadas
+    if features and predictor.df is not None:
+        # Calcular correlações com preço
         correlations = predictor.df.corr()['price'].abs().sort_values(ascending=False)
-        top_features = correlations[1:6].index.tolist()  # Exclui 'price'
+        
+        # Selecionar automaticamente as 6 features mais correlacionadas (excluindo price)
+        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=feature,
+                    label=f"{feature} (corr: {corr_value:.3f})",
                     value=feature in top_features,
-                    info=f"Corr: {predictor.df.corr()['price'].get(feature, 0):.3f}"
+                    info=f"Média: {predictor.df[feature].mean():.1f}"
                 )
             )
     
-    return message, feature_checkboxes, gr.update(visible=True)
+    return message, gr.Column(feature_checkboxes), gr.update(visible=True)
 
-def train_model_action(selected_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 train_model_action(*checkbox_values):
     """Treina o modelo com features selecionadas"""
-    # Converter lista de booleanos para lista de nomes de features
-    all_features = predictor.get_numeric_features()
-    selected_feature_names = [feature for feature, selected in zip(all_features, selected_features) if selected]
+    selected_features = get_selected_features_from_checkboxes(*checkbox_values)
     
-    success, result = predictor.train_model(selected_feature_names)
+    success, result = predictor.train_model(selected_features)
     
     if success:
         metrics_text = f"""
-        📊 **Métricas do Modelo:**
+        ## 📊 Resultados do Modelo
         
-        • R² Treino: {result['r2_train']:.4f}
-        • R² Teste: {result['r2_test']:.4f}
-        • RMSE Teste: ${result['rmse_test']:,.2f}
-        • MAE Teste: ${result['mae_test']:,.2f}
+        ### Métricas de Desempenho:
+        - **R² Treino**: {result['r2_train']:.4f}
+        - **R² Teste**: {result['r2_test']:.4f} 
+        - **RMSE Teste**: ${result['rmse_test']:,.0f}
+        - **MAE Teste**: ${result['mae_test']:,.0f}
         
-        🎯 **Features Selecionadas (por importância):**
+        ### 🎯 Features por Importância:
         """
         
         for i, feature in enumerate(result['top_features']):
-            impact = "📈 Aumenta preço" if feature['Coeficiente'] > 0 else "📉 Diminui preço"
-            metrics_text += f"\n{i+1}. {feature['Feature']}: {feature['Coeficiente']:.4f} ({impact})"
+            direction = "📈 Aumenta preço" if feature['Coeficiente'] > 0 else "📉 Diminui preço"
+            metrics_text += f"\n{i+1}. **{feature['Feature']}**: {feature['Coeficiente']:.4f} ({direction})"
+        
+        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)
 
-def create_correlation_plot(selected_features):
-    """Cria gráfico de correlação das features selecionadas"""
-    if predictor.df is None or not selected_features:
+def create_correlation_plot():
+    """Cria gráfico de correlação das features numéricas"""
+    if predictor.df is None:
         return None
     
     try:
-        features_to_plot = selected_features + ['price']
-        corr_matrix = predictor.df[features_to_plot].corr()
+        # Selecionar apenas algumas features para não sobrecarregar o gráfico
+        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
+            correlations = predictor.df.corr()['price'].abs().sort_values(ascending=False)
+            top_features = correlations.index[:8].tolist()
+        else:
+            top_features = numeric_cols
         
-        fig, ax = plt.subplots(figsize=(10, 8))
-        sns.heatmap(corr_matrix, annot=True, fmt='.2f', cmap='coolwarm', center=0,
-                   square=True, linewidths=1, cbar_kws={"shrink": 0.8}, ax=ax)
-        ax.set_title('Matriz de Correlação - Features Selecionadas', fontsize=14, fontweight='bold')
+        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 entre Variáveis\n(Valores próximos de 1 ou -1 indicam forte correlação)', 
+                    fontsize=14, fontweight='bold', pad=20)
         plt.tight_layout()
         return fig
     except Exception as e:
         print(f"Erro no gráfico de correlação: {e}")
         return None
 
-def create_distribution_plot(selected_feature):
-    """Cria gráfico de distribuição e relação com preço"""
+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 de distribuição
-        fig1, ax1 = plt.subplots(figsize=(10, 4))
-        ax1.hist(predictor.df[selected_feature], bins=30, edgecolor='black', alpha=0.7, color='lightblue')
+        # Gráfico 1: Distribuição da feature
+        fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
+        
+        # Histograma da distribuição
+        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.set_title(f'📊 Distribuição de {selected_feature}')
+        ax1.legend()
         ax1.grid(True, alpha=0.3)
-        plt.tight_layout()
         
-        # Gráfico de dispersão vs preço
-        fig2, ax2 = plt.subplots(figsize=(10, 4))
-        ax2.scatter(predictor.df[selected_feature], predictor.df['price'], alpha=0.5, s=20, color='steelblue')
-        ax2.set_xlabel(selected_feature)
-        ax2.set_ylabel('Preço ($)')
-        correlation = predictor.df[selected_feature].corr(predictor.df['price'])
-        ax2.set_title(f'Relação com Preço (Corr: {correlation:.3f})')
+        # 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)
         
-        # Linha de tendência
-        if len(predictor.df[selected_feature].unique()) > 10:  # Só para variáveis contínuas
+        plt.tight_layout()
+        
+        # Gráfico 2: Relação com preço
+        fig2, ax = plt.subplots(figsize=(10, 6))
+        
+        if predictor.df[selected_feature].nunique() < 10:  # Variável categórica
+            # Boxplot por categoria
+            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})')
+            
+            # 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)
+            ax.plot(x_range, p(x_range), "r--", linewidth=2, alpha=0.8, label='Tendência')
+            ax.legend()
         
+        ax.grid(True, alpha=0.3)
         plt.tight_layout()
+        
         return fig1, fig2
         
     except Exception as e:
-        print(f"Erro nos gráficos de distribuição: {e}")
+        print(f"Erro nos gráficos de análise: {e}")
         return None, None
 
 def create_price_distribution_plot():
@@ -281,35 +370,58 @@ def create_price_distribution_plot():
     if predictor.df is None:
         return None
     
-    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, 
+    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, 
                label=f'Média: ${predictor.df["price"].mean():,.0f}')
-    ax.axvline(predictor.df['price'].median(), color='green', linestyle='--', linewidth=2, 
+    ax1.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('Frequência')
-    ax.set_title('Distribuição dos Preços dos Imóveis')
-    ax.legend()
-    ax.grid(True, alpha=0.3)
+    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}'))
+    
     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"
+        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}:**
+    ## 📈 Estatísticas de **{feature}**
+    
+    **Valores Básicos:**
     - 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
     """
 
 def create_prediction_inputs(metrics_result):
@@ -323,16 +435,22 @@ def create_prediction_inputs(metrics_result):
             min_val = float(predictor.df[feature].min())
             max_val = float(predictor.df[feature].max())
             mean_val = float(predictor.df[feature].mean())
-            std_val = float(predictor.df[feature].std())
+            
+            # 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=f"🏠 {feature}",
                     minimum=min_val,
                     maximum=max_val,
                     value=mean_val,
-                    step=(max_val - min_val) / 100,
-                    info=f"Média: {mean_val:.2f} ± {std_val:.2f}"
+                    step=step,
+                    info=f"Range: {min_val:.1f} - {max_val:.1f}"
                 )
             )
     
@@ -341,16 +459,17 @@ 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. Treine o modelo primeiro.", None
+        return "❌ Modelo não treinado. Por favor, 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):
-                input_features[feature] = feature_values[i]
+                if i < len(feature_values):
+                    input_features[feature] = feature_values[i]
         else:
-            return "❌ Nenhuma feature selecionada", None
+            return "❌ Nenhuma feature selecionada no modelo", None
         
         pred_price, error = predictor.predict_price(input_features)
         
@@ -361,14 +480,15 @@ def predict_price_action(*feature_values):
         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 do Imóvel
         
-        💰 **Preço Estimado: ${pred_price:,.2f}**
+        ### 💰 **Preço Estimado: ${pred_price:,.2f}**
         
-        **Características informadas:**
+        ### 📋 Características Informadas:
         {features_summary}
         
-        *Nota: Esta é uma estimativa baseada no modelo de regressão linear treinado.*
+        ---
+        *💡 Nota: Esta é uma estimativa baseada no modelo de regressão linear treinado com dados de King County.*
         """
         
         return result_text, pred_price
@@ -377,119 +497,94 @@ 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") as demo:
+with gr.Blocks(title="🏠 Análise e Previsão de Preços de Imóveis - King County") as demo:
     gr.Markdown(
         """
         # 🏠 Análise e Previsão de Preços de Imóveis
+        ## King County, Washington - USA
         
-        ## 📋 Sobre este Projeto
-        
-        Este aplicativo realiza análise exploratória e previsão de preços de imóveis usando:
-        - **Regressão Linear Múltipla** para modelagem
-        - **Análise estatística** das características dos imóveis
-        - **Visualizações interativas** para compreensão dos dados
+        ### 📊 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.
         
-        ### 🎯 Objetivos dos Gráficos:
-        
-        1. **Distribuição de Preços**: Mostra como os preços estão distribuídos (normal, assimétrica)
-        2. **Matriz de Correlação**: Revela relações entre features e preço
-        3. **Distribuição por Feature**: Analisa cada característica individualmente
-        4. **Relação com Preço**: Mostra como cada feature influencia o preço
+        ### 🎯 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
         
         """
     )
     
-    with gr.Tab("🚀 Inicialização"):
-        gr.Markdown("### Passo 1: Carregar Dados")
-        load_btn = gr.Button("📂 Carregar Dados do Dataset", variant="primary")
-        load_status = gr.Markdown("Clique no botão para carregar os dados...")
-        
-        gr.Markdown("### Passo 2: Selecionar Features para o Modelo")
-        feature_selection = gr.Column()
-        train_btn = gr.Button("🤖 Treinar Modelo com Features Selecionadas", variant="primary", visible=False)
+    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...")
         
         load_btn.click(
             load_data_action,
             outputs=[load_status, feature_selection, train_btn]
         )
     
-    with gr.Tab("📈 Análise Exploratória"):
-        gr.Markdown("### Análise Completa dos Dados")
+    with gr.Tab("📈 2. Análise Exploratória"):
+        gr.Markdown("### Explore os Dados e Visualize Relações")
         
         with gr.Row():
             with gr.Column():
-                gr.Markdown("#### Distribuição Geral de Preços")
-                price_plot_btn = gr.Button("📊 Gerar Gráfico de Preços")
+                gr.Markdown("#### 📊 Distribuição de Preços")
+                price_plot_btn = gr.Button("🎨 Gerar Gráfico de Preços", variant="primary")
                 price_plot = gr.Plot()
             
             with gr.Column():
-                gr.Markdown("#### Estatísticas por Feature")
+                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 feature para análise detalhada",
+                    label="Selecione uma característica para análise detalhada",
                     choices=[],
                     interactive=True
                 )
-                feature_stats = gr.Markdown("Selecione uma feature...")
+                feature_stats = gr.Markdown("Selecione uma feature acima...")
+            
+            with gr.Column():
+                feature_analysis_btn = gr.Button("📈 Analisar Feature", variant="primary")
         
         with gr.Row():
-            dist_plot1 = gr.Plot(label="Distribuição da Feature")
-            dist_plot2 = gr.Plot(label="Relação com Preço")
-        
-        price_plot_btn.click(
-            create_price_distribution_plot,
-            outputs=[price_plot]
-        )
-        
-        # Atualizar dropdown quando dados forem carregados
-        def update_feature_selector():
-            if predictor.df is not None:
-                features = predictor.get_numeric_features()
-                return gr.update(choices=features, value=features[0] if features else None)
-            return gr.update(choices=[])
-        
-        load_btn.click(
-            update_feature_selector,
-            outputs=[feature_selector]
+            feature_dist_plot = gr.Plot(label="Distribuição da Feature")
+            feature_price_plot = gr.Plot(label="Relação com Preço")
+        
+        # Conectar 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]
         )
-        
         feature_selector.change(
             get_feature_stats,
             inputs=[feature_selector],
             outputs=[feature_stats]
-        ).then(
-            create_distribution_plot,
-            inputs=[feature_selector],
-            outputs=[dist_plot1, dist_plot2]
-        )
-    
-    with gr.Tab("🔍 Correlações"):
-        gr.Markdown("### Análise de Correlações entre Features")
-        gr.Markdown("""
-        **📊 Sobre a Matriz de Correlação:**
-        - **Cores vermelhas**: Correlação positiva (quanto maior a feature, maior o preço)
-        - **Cores azuis**: Correlação negativa (quanto maior a feature, menor o preço)
-        - **Valores próximos de 1 ou -1**: Forte correlação
-        - **Valores próximos de 0**: Fraca ou nenhuma correlação
-        """)
-        
-        correlation_btn = gr.Button("🔄 Gerar Matriz de Correlação", variant="primary")
-        correlation_plot = gr.Plot()
-        
-        correlation_btn.click(
-            lambda: create_correlation_plot(predictor.get_numeric_features()),
-            outputs=[correlation_plot]
         )
     
-    with gr.Tab("🎯 Treinar Modelo"):
-        gr.Markdown("### Treinamento do Modelo de Previsão")
+    with gr.Tab("🤖 3. Treinar Modelo"):
+        gr.Markdown("### Configure e Treine o Modelo de Previsão")
         gr.Markdown("""
-        **📝 Como funciona:**
-        1. Selecione as features que deseja usar no modelo
-        2. Features com alta correlação com preço geralmente são melhores preditoras
-        3. O modelo será treinado e avaliado automaticamente
+        **🎯 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 e clique em 'Treinar Modelo'")
+        feature_selection = gr.Column()
+        train_btn = gr.Button("🚀 Treinar Modelo de Previsão", variant="primary", size="lg", visible=False)
+        train_output = gr.Markdown("Selecione as features acima e clique em 'Treinar Modelo'")
         metrics_display = gr.JSON(label="Métricas Detalhadas", visible=False)
         
         train_btn.click(
@@ -498,18 +593,19 @@ with gr.Blocks(title="Análise e Previsão de Preços de Imóveis") as demo:
             outputs=[train_output, metrics_display, metrics_display]
         )
     
-    with gr.Tab("💰 Fazer Previsão"):
+    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 obter uma previsão de preço:")
+        gr.Markdown("Ajuste os valores das características para estimar o preço de um imóvel:")
         
         prediction_inputs = gr.Column()
-        predict_btn = gr.Button("🎯 Calcular Preço do Imóvel", variant="primary")
+        predict_btn = gr.Button("🎯 Calcular Preço do Imóvel", variant="primary", size="lg")
         
-        prediction_output = gr.Markdown("Preencha os valores e clique em 'Calcular Preço'")
-        price_result = gr.Number(
-            label="Preço Previsto ($)",
-            visible=False
-        )
+        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
+            )
         
         # Atualizar inputs quando modelo for treinado
         metrics_display.change(
@@ -527,49 +623,67 @@ with gr.Blocks(title="Análise e Previsão de Preços de Imóveis") as demo:
             outputs=[price_result]
         )
     
-    with gr.Tab("📚 Explicações"):
+    with gr.Tab("📚 5. Explicações"):
         gr.Markdown(
             """
-            ## 📊 Explicação dos Gráficos e Análises
-            
-            ### 1. Distribuição de Preços
-            **Objetivo**: Entender a distribuição dos preços no mercado
-            - **Histograma**: Mostra a frequência de imóveis em cada faixa de preço
-            - **Linhas verticais**: Média (vermelha) e Mediana (verde)
-            - **Interpretação**: 
-                - Distribuição normal: curva simétrica
-                - Assimetria positiva: mais imóveis baratos, alguns muito caros
-                - Assimetria negativa: mais imóveis caros, alguns muito baratos
-            
-            ### 2. Matriz de Correlação
-            **Objetivo**: Identificar relações entre variáveis
-            - **Correlação positiva (vermelho)**: Ambas variáveis aumentam juntas
-            - **Correlação negativa (azul)**: Uma aumenta enquanto a outra diminui
-            - **Valores**: -1 (correlação negativa perfeita) a +1 (correlação positiva perfeita)
-            - **Para previsão**: Buscamos features com alta correlação com 'price'
-            
-            ### 3. Análise por Feature Individual
-            **Dois gráficos para cada feature:**
-            - **Distribuição**: Como os valores da feature se distribuem
-            - **Relação com Preço**: Como a feature influencia o preço
-            - **Linha de tendência**: Mostra a direção da relação
-            
-            ### 4. Métricas do Modelo
-            - **R² (R-quadrado)**: Proporção da variância explicada (0-1, quanto maior melhor)
-            - **RMSE**: Erro médio em dólares (penaliza erros grandes)
-            - **MAE**: Erro absoluto médio em dólares
-            - **Coeficientes**: Impacto de cada feature no preço
-            
-            ### 🎯 Dicas para Melhor Previsão:
-            1. Use features com alta correlação com preço
-            2. Evite features muito correlacionadas entre si
-            3. Verifique se as relações são lineares nos gráficos
-            4. Considere transformações para features com distribuições assimétricas
+            ## 📊 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
             """
         )
 
-# Inicializar dados ao carregar
-predictor.load_data()
+# Inicializar dados ao carregar a interface
+def initialize_app():
+    """Inicializa o aplicativo carregando dados e atualizando interfaces"""
+    load_status = predictor.load_data()
+    features = predictor.get_numeric_features()
+    
+    # Atualizar dropdown de features
+    feature_choices = gr.update(choices=features, value=features[0] if features else None)
+    
+    return load_status, feature_choices
+
+# Inicializar quando o app carregar
+demo.load(initialize_app, outputs=[load_status, feature_selector])
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(share=True)