Update app.py

app.py

@@ -16,73 +16,6 @@ sns.set_style("whitegrid")
 plt.rcParams['figure.figsize'] = (12, 6)
 plt.rcParams['font.size'] = 10
 
-# 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)
-    
-    print("🎯 Gerando dados do King County...")
-    
-    # Gerar características básicas
-    sqft_living = np.random.normal(2080, 920, n_samples)
-    sqft_living = np.clip(sqft_living, 370, 13540)
-    
-    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])
-    
-    yr_built = np.random.randint(1900, 2016, n_samples)
-    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 +
-        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
-    )
-    
-    noise = np.random.normal(0, 150000, n_samples)
-    price = base_price + noise
-    price = np.clip(price, 75000, 5000000)
-    
-    # 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),
-        'sqft_above': sqft_living * 0.8,
-        'sqft_basement': sqft_living * 0.2,
-    }
-    
-    df = pd.DataFrame(data)
-    print(f"✅ Dados gerados: {df.shape[0]} imóveis, {df.shape[1]} características")
-    print(f"💰 Preço médio: ${df['price'].mean():,.2f}")
-    return df
-
 class HousePricePredictor:
     def __init__(self):
         self.model = None
@@ -93,17 +26,46 @@ class HousePricePredictor:
         self._data_loaded = False
         
     def load_data(self):
-        """Carrega dados gerados"""
+        """Carrega dados do arquivo kc_house_data.csv"""
         try:
             if not self._data_loaded:
-                self.df = generate_king_county_data()
+                print("📂 Tentando carregar kc_house_data.csv...")
+                
+                # Tentar carregar do arquivo local (Hugging Face Files)
+                self.df = pd.read_csv('kc_house_data.csv')
+                
+                # Limpeza básica dos dados
+                self._clean_data()
+                
                 self._data_loaded = True
+                print(f"✅ Dados carregados: {self.df.shape[0]} imóveis × {self.df.shape[1]} características")
                 return f"✅ Dados carregados: {self.df.shape[0]} imóveis × {self.df.shape[1]} características"
             else:
                 return f"✅ Dados já carregados: {self.df.shape[0]} imóveis × {self.df.shape[1]} características"
+                
         except Exception as e:
+            print(f"❌ Erro ao carregar arquivo: {e}")
             return f"❌ Erro ao carregar dados: {str(e)}"
     
+    def _clean_data(self):
+        """Faz limpeza básica dos dados"""
+        # Remover colunas não numéricas problemáticas
+        if 'date' in self.df.columns:
+            self.df = self.df.drop(columns=['date'])
+        if 'id' in self.df.columns:
+            self.df = self.df.drop(columns=['id'])
+        
+        # Remover linhas com valores missing
+        self.df = self.df.dropna()
+        
+        # Remover outliers extremos no preço
+        Q1 = self.df['price'].quantile(0.01)
+        Q3 = self.df['price'].quantile(0.99)
+        self.df = self.df[(self.df['price'] >= Q1) & (self.df['price'] <= Q3)]
+        
+        print(f"📊 Dados limpos: {self.df.shape[0]} imóveis")
+        print(f"💰 Preço médio: ${self.df['price'].mean():,.2f}")
+    
     def get_numeric_features(self):
         """Retorna lista de features numéricas (excluindo price)"""
         if self.df is None:
@@ -124,7 +86,7 @@ class HousePricePredictor:
             
             self.selected_features = selected_features
             X = self.df[selected_features]
-            y = np.log1p(self.df['price'])
+            y = np.log1p(self.df['price'])  # Transformação logarítmica
             
             # Dividir dados
             X_train, X_test, y_train, y_test = train_test_split(
@@ -204,7 +166,7 @@ class HousePricePredictor:
 # Instanciar o predictor
 predictor = HousePricePredictor()
 
-# Carregar dados uma vez no início
+# Carregar dados automaticamente ao iniciar
 print("🚀 Iniciando aplicação...")
 initial_message = predictor.load_data()
 initial_features = predictor.get_numeric_features()
@@ -233,7 +195,8 @@ def load_data_action():
             feature_checkboxes.append(
                 gr.Checkbox(
                     label=f"{feature} (corr: {corr_value:.3f})",
-                    value=feature in top_features
+                    value=feature in top_features,
+                    info=f"Média: {predictor.df[feature].mean():.1f}"
                 )
             )
     
@@ -280,7 +243,7 @@ def train_model_action(*checkbox_values):
 def create_correlation_plot():
     """Cria gráfico de correlação"""
     if predictor.df is None:
-        return gr.update(value=None)
+        return None
     
     try:
         # Selecionar features mais importantes
@@ -293,10 +256,10 @@ def create_correlation_plot():
         
         corr_matrix = predictor.df[top_features].corr()
         
-        fig, ax = plt.subplots(figsize=(10, 8))
+        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', fontsize=14, fontweight='bold')
+        ax.set_title('🔗 Matriz de Correlação - Dataset Real King County', fontsize=14, fontweight='bold')
         plt.tight_layout()
         return fig
     except Exception as e:
@@ -310,17 +273,19 @@ def create_feature_analysis_plot(selected_feature):
     
     try:
         # Gráfico 1: Distribuição
-        fig1, ax1 = plt.subplots(figsize=(8, 4))
+        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)
+        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 2: Relação com preço
-        fig2, ax2 = plt.subplots(figsize=(8, 4))
+        fig2, ax2 = plt.subplots(figsize=(10, 5))
         
         if predictor.df[selected_feature].nunique() < 10:
             # Boxplot para variáveis categóricas
@@ -332,20 +297,24 @@ def create_feature_analysis_plot(selected_feature):
             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')
+            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)
+            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'Relação com Preço (Corr: {correlation:.3f})')
+        ax2.set_title(f'💰 Preço vs {selected_feature} (Corr: {correlation:.3f})')
         ax2.grid(True, alpha=0.3)
-        plt.tight_layout()
         
+        # 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:
@@ -357,7 +326,7 @@ def create_price_distribution_plot():
     if predictor.df is None:
         return None
     
-    fig, ax = plt.subplots(figsize=(10, 5))
+    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}')
@@ -365,9 +334,13 @@ def create_price_distribution_plot():
                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 dos Imóveis - King County')
+    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
 
@@ -380,7 +353,7 @@ def get_feature_stats(feature):
     correlation = predictor.df[feature].corr(predictor.df['price'])
     
     return f"""
-    ## 📊 Estatísticas de **{feature}**
+    ## 📈 Estatísticas de **{feature}**
     
     **Valores:**
     - Média: {stats['mean']:.2f}
@@ -389,6 +362,11 @@ def get_feature_stats(feature):
     - 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
@@ -409,6 +387,8 @@ def create_prediction_inputs(metrics_result):
             step = (max_val - min_val) / 100
             if step < 0.1:
                 step = 0.1
+            elif step > 100:
+                step = 10
             
             inputs.append(
                 gr.Slider(
@@ -416,7 +396,8 @@ def create_prediction_inputs(metrics_result):
                     minimum=min_val,
                     maximum=max_val,
                     value=mean_val,
-                    step=step
+                    step=step,
+                    info=f"Range: {min_val:.1f} - {max_val:.1f}"
                 )
             )
     
@@ -452,7 +433,7 @@ def predict_price_action(*feature_values):
         {features_summary}
         
         ---
-        *Nota: Previsão baseada no modelo de regressão linear treinado.*
+        *💡 Nota: Previsão baseada no modelo treinado com dados reais do King County.*
         """
         
         return result_text, pred_price
@@ -461,14 +442,15 @@ 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 - King County Dataset Real") as demo:
     gr.Markdown(
         """
         # 🏠 Análise e Previsão de Preços de Imóveis
-        ## King County, Washington - USA
+        ## 📊 Dataset Real - King County, Washington
         
-        ### 📊 Dados Carregados Automaticamente
-        Este aplicativo utiliza dados **realísticos** simulando o mercado imobiliário de King County.
+        ### ℹ️ 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.
         """
     )
     
@@ -476,31 +458,35 @@ with gr.Blocks(title="🏠 Análise e Previsão de Preços de Imóveis") as demo
     initial_status = gr.Markdown(f"**Status:** {initial_message}")
     
     with gr.Tab("🚀 Iniciar"):
-        gr.Markdown("### Bem-vindo ao Analisador de Preços de Imóveis!")
-        
-        gr.Markdown("""
-        **🎯 O que você pode fazer:**
-        
-        1. **📊 Análise Exploratória** - Explore gráficos e estatísticas dos dados
-        2. **🤖 Treinar Modelo** - Selecione features e treine um modelo de previsão  
-        3. **💰 Fazer Previsão** - Estime preços com base nas características
-        4. **📚 Explicações** - Entenda os conceitos e interpretações
-        
-        **Dados disponíveis:**
-        - Preços de imóveis de $75,000 a $5,000,000
-        - Características como área, quartos, banheiros, localização
-        - 2,000 imóveis simulados do mercado de King County
+        gr.Markdown("### Bem-vindo ao Analisador de Dados Reais do King County!")
+        
+        gr.Markdown(f"""
+        **📊 Dataset Carregado:**
+        - **Arquivo**: kc_house_data.csv
+        - **Imóveis**: {predictor.df.shape[0] if predictor.df else 'Carregando...'}
+        - **Características**: {predictor.df.shape[1] if predictor.df else 'Carregando...'}
+        - **Preço Médio**: ${predictor.df['price'].mean():,.2f' if predictor.df else 'Carregando...'}
+        
+        **🎯 Funcionalidades:**
+        1. **📊 Análise Exploratória** - Gráficos com dados reais
+        2. **🤖 Treinar Modelo** - Machine Learning com features selecionadas  
+        3. **💰 Fazer Previsão** - Estime preços baseado no modelo
+        4. **📚 Explicações** - Entenda as análises
         """)
         
         load_btn = gr.Button("🔄 Recarregar Dados", variant="secondary")
-        load_btn.click(load_data_action, outputs=[initial_status, feature_selection, train_btn])
+        load_status = gr.Markdown()
+        feature_selection = gr.Column()
+        train_btn = gr.Button("🚀 Treinar Modelo", variant="primary", visible=False)
+        
+        load_btn.click(load_data_action, outputs=[load_status, feature_selection, train_btn])
 
     with gr.Tab("📊 Análise Exploratória"):
-        gr.Markdown("### Explore os Dados e Visualize Relações")
+        gr.Markdown("### Explore os Dados Reais do King County")
         
         with gr.Row():
             with gr.Column():
-                gr.Markdown("#### 📈 Distribuição de Preços")
+                gr.Markdown("#### 📈 Distribuição de Preços Reais")
                 price_plot_btn = gr.Button("🎨 Gerar Gráfico de Preços", variant="primary")
                 price_plot = gr.Plot()
             
@@ -537,47 +523,29 @@ with gr.Blocks(title="🏠 Análise e Previsão de Preços de Imóveis") as demo
             outputs=[feature_dist_plot, feature_price_plot]
         )
         
-        # 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])
-        
         # Inicializar estatísticas da primeira feature
         if initial_features:
             feature_stats.value = get_feature_stats(initial_features[0])
+        
+        # Atualizar estatísticas quando feature mudar
+        feature_selector.change(
+            get_feature_stats,
+            inputs=[feature_selector],
+            outputs=[feature_stats]
+        )
 
     with gr.Tab("🤖 Treinar Modelo"):
-        gr.Markdown("### Configure e Treine o Modelo de Previsão")
+        gr.Markdown("### Treine o Modelo com Dados Reais")
         
         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
+        - Selecione as características para prever preços
+        - Features com alta correlação são melhores preditoras
+        - Modelo: **Regressão Linear** com dados reais
+        - **Dataset**: kc_house_data.csv (dados reais)
         """)
         
-        # Criar checkboxes para features
-        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 de Previsão", variant="primary", size="lg", visible=bool(initial_features))
-        train_output = gr.Markdown("Selecione as features acima e clique em 'Treinar Modelo'")
+        train_output = gr.Markdown("Selecione as features e clique em 'Treinar Modelo'")
         metrics_display = gr.JSON(label="Métricas Detalhadas", visible=False)
         
         train_btn.click(
@@ -587,24 +555,24 @@ with gr.Blocks(title="🏠 Análise e Previsão de Preços de Imóveis") as demo
         )
 
     with gr.Tab("💰 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:")
+        gr.Markdown("### Faça Previsões com o Modelo Treinado")
         
         prediction_inputs = gr.Column()
         predict_btn = gr.Button("🎯 Calcular Preço do Imóvel", variant="primary", size="lg")
         
         with gr.Row():
-            prediction_output = gr.Markdown("Preencha os valores acima e clique em 'Calcular Preço'")
+            prediction_output = gr.Markdown("Preencha os valores e clique em 'Calcular Preço'")
             price_result = gr.Number(
                 label="💵 Preço Previsto",
                 visible=False
             )
         
         # Atualizar inputs quando modelo for treinado
-        def update_prediction_inputs(metrics):
-            return create_prediction_inputs(metrics)
-        
-        metrics_display.change(update_prediction_inputs, inputs=[metrics_display], outputs=[prediction_inputs])
+        metrics_display.change(
+            create_prediction_inputs,
+            inputs=[metrics_display],
+            outputs=[prediction_inputs]
+        )
         
         predict_btn.click(
             predict_price_action,
@@ -618,50 +586,57 @@ with gr.Blocks(title="🏠 Análise e Previsão de Preços de Imóveis") as demo
     with gr.Tab("📚 Explicações"):
         gr.Markdown(
             """
-            ## 📊 Guia Completo de Análise
+            ## 📊 Guia do Dataset Real King County
             
-            ### 🏠 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
+            ### 🏠 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
             
-            ### 📈 Interpretação dos Gráficos
+            ### 📈 Variáveis Principais:
+            - **price**: Preço de venda (target)
+            - **sqft_living**: Área habitável (pés quadrados)
+            - **bedrooms**: Número de quartos
+            - **bathrooms**: Número de banheiros
+            - **floors**: Número de andares
+            - **waterfront**: Vista para água (0/1)
+            - **view**: Qualidade da vista (0-4)
+            - **condition**: Condição do imóvel (1-5)
+            - **grade**: Grau de construção (1-13)
+            - **yr_built**: Ano de construção
+            - **lat/long**: Coordenadas geográficas
             
-            #### 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)
+            ### 🎯 Interpretação dos Gráficos
             
-            #### 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
+            #### Distribuição de Preços
+            - Mostra a realidade do mercado imobiliário
+            - Geralmente assimétrica positiva (mais imóveis baratos)
+            - Presença de outliers (imóveis de luxo)
             
-            #### 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
+            #### Matriz de Correlação
+            - Baseada em **dados reais**
+            - Relações observadas no mercado real
+            - Padrões que o modelo aprenderá
             
-            ### 🤖 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
+            #### Análise por Feature
+            - Distribuições reais das características
+            - Relações observadas com preços de venda
+            - Insights do mercado real
             
-            ### 💡 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
+            ### 🤖 Modelo de Machine Learning
+            - **Algoritmo**: Regressão Linear Múltipla
+            - **Base**: Dados reais de vendas
+            - **Aplicação**: Previsão de preços baseada em padrões históricos
             
-            ### 🎯 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
+            ### 💡 Insights do Mercado Real
+            - Features como **sqft_living** e **grade** têm alta correlação
+            - Localização (**lat/long**) é crucial para preços
+            - Características de qualidade impactam significativamente
+            - O modelo captura relações observadas no mercado real
             """
         )
 
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch()