Spaces:
Sleeping
Sleeping
| import pandas as pd | |
| import numpy as np | |
| import matplotlib.pyplot as plt | |
| import seaborn as sns | |
| from scipy import stats | |
| from sklearn.model_selection import train_test_split | |
| from sklearn.linear_model import LinearRegression | |
| from sklearn.preprocessing import StandardScaler | |
| from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error | |
| import gradio as gr | |
| import warnings | |
| warnings.filterwarnings('ignore') | |
| # Configurações de visualização | |
| sns.set_style("whitegrid") | |
| plt.rcParams['figure.figsize'] = (12, 6) | |
| plt.rcParams['font.size'] = 10 | |
| class HousePricePredictor: | |
| def __init__(self): | |
| self.model = None | |
| self.scaler = None | |
| self.df = None | |
| self.is_trained = False | |
| self.selected_features = None | |
| self._data_loaded = False | |
| self.stats = { | |
| 'n_imoveis': 0, | |
| 'n_caracteristicas': 0, | |
| 'preco_medio': 0 | |
| } | |
| def load_data(self): | |
| """Carrega dados do arquivo kc_house_data.csv""" | |
| try: | |
| if not self._data_loaded: | |
| 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() | |
| # Atualizar estatísticas | |
| self.stats = { | |
| 'n_imoveis': self.df.shape[0], | |
| 'n_caracteristicas': self.df.shape[1], | |
| 'preco_medio': self.df['price'].mean() | |
| } | |
| 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: | |
| return [] | |
| numeric_features = self.df.select_dtypes(include=[np.number]).columns.tolist() | |
| if 'price' in numeric_features: | |
| numeric_features.remove('price') | |
| return numeric_features | |
| def get_dataset_stats(self): | |
| """Retorna estatísticas do dataset para display seguro""" | |
| if self.df is not None: | |
| return { | |
| 'n_imoveis': self.df.shape[0], | |
| 'n_caracteristicas': self.df.shape[1], | |
| 'preco_medio': self.df['price'].mean() | |
| } | |
| else: | |
| return { | |
| 'n_imoveis': 0, | |
| 'n_caracteristicas': 0, | |
| 'preco_medio': 0 | |
| } | |
| def train_model(self, selected_features): | |
| """Treina o modelo com as features selecionadas""" | |
| try: | |
| if self.df is None: | |
| return False, "❌ Dados não carregados" | |
| if not selected_features: | |
| return False, "❌ Selecione pelo menos uma feature" | |
| self.selected_features = selected_features | |
| X = self.df[selected_features] | |
| y = np.log1p(self.df['price']) # Transformação logarítmica | |
| # Dividir dados | |
| X_train, X_test, y_train, y_test = train_test_split( | |
| X, y, test_size=0.2, random_state=42 | |
| ) | |
| # Padronizar features | |
| self.scaler = StandardScaler() | |
| X_train_scaled = self.scaler.fit_transform(X_train) | |
| X_test_scaled = self.scaler.transform(X_test) | |
| # Treinar modelo | |
| self.model = LinearRegression() | |
| self.model.fit(X_train_scaled, y_train) | |
| # Fazer previsões | |
| y_pred_train = self.model.predict(X_train_scaled) | |
| y_pred_test = self.model.predict(X_test_scaled) | |
| # Calcular métricas | |
| y_pred_train_orig = np.expm1(y_pred_train) | |
| y_pred_test_orig = np.expm1(y_pred_test) | |
| y_train_orig = np.expm1(y_train) | |
| y_test_orig = np.expm1(y_test) | |
| r2_train = r2_score(y_train_orig, y_pred_train_orig) | |
| r2_test = r2_score(y_test_orig, y_pred_test_orig) | |
| rmse_test = np.sqrt(mean_squared_error(y_test_orig, y_pred_test_orig)) | |
| mae_test = mean_absolute_error(y_test_orig, y_pred_test_orig) | |
| self.is_trained = True | |
| # Coeficientes | |
| coeficientes = pd.DataFrame({ | |
| 'Feature': selected_features, | |
| 'Coeficiente': self.model.coef_, | |
| 'Impacto_Absoluto': np.abs(self.model.coef_) | |
| }).sort_values('Impacto_Absoluto', ascending=False) | |
| return True, { | |
| 'r2_train': r2_train, | |
| 'r2_test': r2_test, | |
| 'rmse_test': rmse_test, | |
| 'mae_test': mae_test, | |
| 'top_features': coeficientes.to_dict('records'), | |
| 'selected_features': selected_features | |
| } | |
| except Exception as e: | |
| return False, f"❌ Erro no treinamento: {str(e)}" | |
| def predict_price(self, input_features_dict): | |
| """Faz previsão de preço para novas entradas""" | |
| if not self.is_trained: | |
| return None, "❌ Modelo não treinado" | |
| try: | |
| # Criar array de features na ordem correta | |
| input_array = [] | |
| for feature in self.selected_features: | |
| input_array.append(float(input_features_dict[feature])) | |
| input_array = np.array(input_array).reshape(1, -1) | |
| # Padronizar | |
| input_scaled = self.scaler.transform(input_array) | |
| # Fazer previsão | |
| pred_log = self.model.predict(input_scaled)[0] | |
| pred_original = np.expm1(pred_log) | |
| return pred_original, None | |
| except Exception as e: | |
| return None, f"❌ Erro na previsão: {str(e)}" | |
| # Instanciar o predictor | |
| predictor = HousePricePredictor() | |
| # Carregar dados automaticamente ao iniciar | |
| print("🚀 Iniciando aplicação...") | |
| initial_message = predictor.load_data() | |
| initial_features = predictor.get_numeric_features() | |
| dataset_stats = predictor.get_dataset_stats() | |
| print(f"📊 Features disponíveis: {initial_features}") | |
| # Funções para a interface Gradio | |
| def load_data_action(): | |
| """Carrega os dados - função para o botão""" | |
| message = predictor.load_data() | |
| features = predictor.get_numeric_features() | |
| # Criar checkboxes para features | |
| feature_checkboxes = [] | |
| if features and predictor.df is not None: | |
| # Calcular correlações com preço | |
| correlations = predictor.df.corr()['price'].abs().sort_values(ascending=False) | |
| # Selecionar automaticamente as 6 features mais correlacionadas | |
| top_features = [] | |
| for feature in correlations.index: | |
| if feature != 'price' and len(top_features) < 6: | |
| top_features.append(feature) | |
| for feature in features: | |
| corr_value = correlations.get(feature, 0) | |
| 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}" | |
| ) | |
| ) | |
| return message, gr.Column(feature_checkboxes), gr.update(visible=True) | |
| 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""" | |
| selected_features = get_selected_features_from_checkboxes(*checkbox_values) | |
| success, result = predictor.train_model(selected_features) | |
| if success: | |
| metrics_text = f""" | |
| ## 📊 Resultados do Modelo | |
| ### 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 por Importância: | |
| """ | |
| for i, feature in enumerate(result['top_features']): | |
| 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(): | |
| """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(metrics_result): | |
| """Cria inputs para previsão""" | |
| if metrics_result is None or 'selected_features' not in metrics_result: | |
| return [] | |
| inputs = [] | |
| 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()) | |
| mean_val = float(predictor.df[feature].mean()) | |
| 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}", | |
| minimum=min_val, | |
| maximum=max_val, | |
| value=mean_val, | |
| step=step, | |
| info=f"Range: {min_val:.1f} - {max_val:.1f}" | |
| ) | |
| ) | |
| return inputs | |
| 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 = {} | |
| 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) | |
| if error: | |
| return f"❌ {error}", None | |
| 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 | |
| ### 💰 **Preço Estimado: ${pred_price:,.2f}** | |
| ### 📋 Características Informadas: | |
| {features_summary} | |
| --- | |
| *💡 Nota: Previsão baseada no modelo treinado com dados reais do King County.* | |
| """ | |
| return result_text, pred_price | |
| 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 | |
| with gr.Blocks(title="🏠 Análise e Previsão - King County Dataset Real") as demo: | |
| gr.Markdown( | |
| """ | |
| # 🏠 Análise e Previsão de Preços de Imóveis | |
| ## 📊 Dataset Real - King County, Washington | |
| ### ℹ️ Sobre os Dados: | |
| Este aplicativo utiliza o **dataset real** `kc_house_data.csv` do mercado imobiliário de King County. | |
| Dados reais de vendas de imóveis com diversas características. | |
| """ | |
| ) | |
| # Status inicial | |
| initial_status = gr.Markdown(f"**Status:** {initial_message}") | |
| dataset_info = gr.Markdown(get_dataset_info()) | |
| with gr.Tab("🚀 Iniciar"): | |
| gr.Markdown("### Bem-vindo ao Analisador de Dados Reais do King County!") | |
| gr.Markdown(get_dataset_info()) | |
| gr.Markdown(""" | |
| **🎯 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_status = gr.Markdown() | |
| feature_selection = gr.Column() | |
| train_btn = gr.Button("🚀 Treinar Modelo", variant="primary", visible=False) | |
| def update_after_load(): | |
| message = predictor.load_data() | |
| info = get_dataset_info() | |
| features = predictor.get_numeric_features() | |
| # Criar checkboxes | |
| feature_checkboxes = [] | |
| if 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 features: | |
| corr_value = correlations.get(feature, 0) | |
| feature_checkboxes.append( | |
| gr.Checkbox( | |
| label=f"{feature} (corr: {corr_value:.3f})", | |
| value=feature in top_features | |
| ) | |
| ) | |
| return message, info, gr.Column(feature_checkboxes), gr.update(visible=True) | |
| load_btn.click( | |
| update_after_load, | |
| outputs=[load_status, dataset_info, feature_selection, train_btn] | |
| ) | |
| with gr.Tab("📊 Análise Exploratória"): | |
| gr.Markdown("### Explore os Dados Reais do King County") | |
| with gr.Row(): | |
| with gr.Column(): | |
| gr.Markdown("#### 📈 Distribuição de Preços Reais") | |
| price_plot_btn = gr.Button("🎨 Gerar Gráfico de Preços", variant="primary") | |
| 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") | |
| 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 característica para análise detalhada", | |
| choices=initial_features, | |
| value=initial_features[0] if initial_features else None | |
| ) | |
| feature_stats = gr.Markdown() | |
| with gr.Column(): | |
| feature_analysis_btn = gr.Button("📈 Analisar Feature", variant="primary") | |
| with gr.Row(): | |
| feature_dist_plot = gr.Plot(label="Distribuição da Feature") | |
| feature_price_plot = gr.Plot(label="Relação com Preço") | |
| # 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 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("### Treine o Modelo com Dados Reais") | |
| gr.Markdown(""" | |
| **🎯 Como Funciona:** | |
| - 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) | |
| """) | |
| 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( | |
| train_model_action, | |
| inputs=[feature_selection], | |
| outputs=[train_output, metrics_display, metrics_display] | |
| ) | |
| with gr.Tab("💰 Fazer Previsão"): | |
| 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 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( | |
| 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] | |
| ) | |
| with gr.Tab("📚 Explicações"): | |
| gr.Markdown( | |
| """ | |
| ## 📊 Guia do Dataset Real King County | |
| ### 🏠 Sobre os Dados Reais | |
| **King County** inclui Seattle e áreas metropolitanas. O dataset contém: | |
| - **Vendas reais** de imóveis | |
| - **Período**: Maio 2014 - Maio 2015 | |
| - **Características**: 21 colunas incluindo localização, tamanho, qualidade | |
| - **Preços**: Variam de dezenas de milhares a milhões de dólares | |
| ### 📈 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 | |
| ### 🎯 Interpretação dos Gráficos | |
| #### 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) | |
| #### Matriz de Correlação | |
| - Baseada em **dados reais** | |
| - Relações observadas no mercado real | |
| - Padrões que o modelo aprenderá | |
| #### Análise por Feature | |
| - Distribuições reais das características | |
| - Relações observadas com preços de venda | |
| - Insights do mercado real | |
| ### 🤖 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 | |
| ### 💡 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() |