Create app.py

app.py

@@ -0,0 +1,426 @@
+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.feature_names = None
+        self.df = None
+        self.is_trained = False
+        
+    def load_and_prepare_data(self, file_path):
+        """Carrega e prepara os dados"""
+        try:
+            self.df = pd.read_csv(file_path)
+            print(f"✅ Dados carregados: {self.df.shape[0]} linhas × {self.df.shape[1]} colunas")
+            
+            # Preparar features
+            features_to_drop = ['id', 'date'] if 'date' in self.df.columns else ['id']
+            X = self.df.drop(columns=features_to_drop + ['price'], errors='ignore')
+            X = X.select_dtypes(include=[np.number])
+            y = self.df['price']
+            
+            self.feature_names = X.columns.tolist()
+            return True, f"Dados carregados com sucesso! {len(self.feature_names)} features identificadas."
+            
+        except Exception as e:
+            return False, f"Erro ao carregar dados: {str(e)}"
+    
+    def train_model(self):
+        """Treina o modelo de regressão linear"""
+        try:
+            # Preparar dados
+            features_to_drop = ['id', 'date'] if 'date' in self.df.columns else ['id']
+            X = self.df.drop(columns=features_to_drop + ['price'], errors='ignore')
+            X = X.select_dtypes(include=[np.number])
+            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': self.feature_names,
+                'Coeficiente': self.model.coef_
+            }).sort_values('Coeficiente', key=abs, ascending=False)
+            
+            return True, {
+                'r2_train': r2_train,
+                'r2_test': r2_test,
+                'rmse_test': rmse_test,
+                'mae_test': mae_test,
+                'top_features': coeficientes.head(10).to_dict('records')
+            }
+            
+        except Exception as e:
+            return False, f"Erro no treinamento: {str(e)}"
+    
+    def predict_price(self, input_features):
+        """Faz previsão de preço para novas entradas"""
+        if not self.is_trained:
+            return None, "Modelo não treinado. Por favor, treine o modelo primeiro."
+        
+        try:
+            # Criar array de features na ordem correta
+            input_array = []
+            for feature in self.feature_names:
+                input_array.append(float(input_features[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()
+
+def load_data(file):
+    """Função para carregar dados do arquivo"""
+    if file is None:
+        return "❌ Por favor, faça upload do arquivo CSV", None
+    
+    success, message = predictor.load_and_prepare_data(file.name)
+    if success:
+        return message, gr.update(visible=True)
+    else:
+        return message, gr.update(visible=False)
+
+def train_model_action():
+    """Função para treinar o modelo"""
+    if predictor.df is None:
+        return "❌ Por favor, carregue os dados primeiro.", None, gr.update(visible=False)
+    
+    success, result = predictor.train_model()
+    
+    if success:
+        metrics_text = f"""
+        📊 **Métricas 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}
+        
+        🎯 **Top 5 Features Mais Importantes:**
+        """
+        
+        for i, feature in enumerate(result['top_features'][:5]):
+            impact = "📈 Aumenta preço" if feature['Coeficiente'] > 0 else "📉 Diminui preço"
+            metrics_text += f"\n{i+1}. {feature['Feature']}: {feature['Coeficiente']:.4f} ({impact})"
+        
+        return metrics_text, result, gr.update(visible=True)
+    else:
+        return result, None, gr.update(visible=False)
+
+def create_prediction_interface(metrics_result):
+    """Cria a interface de previsão baseada nas features disponíveis"""
+    if predictor.feature_names is None:
+        return gr.update(visible=False)
+    
+    # Criar inputs para cada feature
+    inputs = []
+    default_values = {}
+    
+    # Calcular valores médios para preenchimento automático
+    if predictor.df is not None:
+        for feature in predictor.feature_names:
+            mean_val = predictor.df[feature].mean()
+            default_values[feature] = mean_val
+    
+    for feature in predictor.feature_names:
+        min_val = float(predictor.df[feature].min())
+        max_val = float(predictor.df[feature].max())
+        mean_val = float(predictor.df[feature].mean())
+        
+        inputs.append(
+            gr.Number(
+                label=feature,
+                value=mean_val,
+                minimum=min_val,
+                maximum=max_val,
+                info=f"Range: {min_val:.1f} - {max_val:.1f}"
+            )
+        )
+    
+    return inputs
+
+def predict_price_action(*feature_values):
+    """Função para fazer previsão de preço"""
+    if not predictor.is_trained:
+        return "❌ Modelo não treinado. Por favor, treine o modelo primeiro.", None
+    
+    # Criar dicionário de features
+    input_features = {}
+    for i, feature in enumerate(predictor.feature_names):
+        input_features[feature] = feature_values[i]
+    
+    pred_price, error = predictor.predict_price(input_features)
+    
+    if error:
+        return f"❌ {error}", None
+    
+    # Criar visualização dos inputs
+    features_text = "**Características do Imóvel:**\n"
+    for feature, value in input_features.items():
+        features_text += f"\n• {feature}: {value}"
+    
+    result_text = f"""
+    🏠 **Previsão de Preço**
+    
+    💰 **Preço Estimado: ${pred_price:,.2f}**
+    
+    {features_text}
+    
+    *Nota: Esta é uma estimativa baseada no modelo de regressão linear.*
+    """
+    
+    return result_text, pred_price
+
+def create_analysis_plots():
+    """Cria gráficos de análise exploratória"""
+    if predictor.df is None:
+        return None, None, None
+    
+    try:
+        # Gráfico 1: Distribuição de preços
+        fig1, ax1 = plt.subplots(figsize=(10, 6))
+        ax1.hist(predictor.df['price'], bins=50, edgecolor='black', alpha=0.7, color='steelblue')
+        ax1.axvline(predictor.df['price'].mean(), color='red', linestyle='--', 
+                   label=f'Média: ${predictor.df["price"].mean():,.0f}')
+        ax1.axvline(predictor.df['price'].median(), color='green', linestyle='--', 
+                   label=f'Mediana: ${predictor.df["price"].median():,.0f}')
+        ax1.set_xlabel('Preço ($)')
+        ax1.set_ylabel('Frequência')
+        ax1.set_title('Distribuição dos Preços dos Imóveis')
+        ax1.legend()
+        ax1.grid(True, alpha=0.3)
+        
+        # Gráfico 2: Correlações
+        numeric_cols = predictor.df.select_dtypes(include=[np.number]).columns.tolist()
+        correlations = predictor.df[numeric_cols].corr()['price'].sort_values(ascending=False)
+        top_corr = correlations[1:11]
+        
+        fig2, ax2 = plt.subplots(figsize=(10, 6))
+        colors = ['green' if x > 0 else 'red' for x in top_corr.values]
+        bars = ax2.barh(range(len(top_corr)), top_corr.values, color=colors, alpha=0.7, edgecolor='black')
+        ax2.set_yticks(range(len(top_corr)))
+        ax2.set_yticklabels(top_corr.index)
+        ax2.set_xlabel('Coeficiente de Correlação')
+        ax2.set_title('Top 10 Variáveis Correlacionadas com Preço')
+        ax2.axvline(0, color='black', linewidth=0.8)
+        ax2.grid(True, alpha=0.3, axis='x')
+        
+        for i, (bar, val) in enumerate(zip(bars, top_corr.values)):
+            ax2.text(val + 0.01 if val > 0 else val - 0.01, i, f'{val:.3f}',
+                    va='center', ha='left' if val > 0 else 'right', fontsize=9, fontweight='bold')
+        
+        # Gráfico 3: Scatter plot da feature mais correlacionada
+        most_correlated_feature = top_corr.index[0]
+        fig3, ax3 = plt.subplots(figsize=(10, 6))
+        ax3.scatter(predictor.df[most_correlated_feature], predictor.df['price'], 
+                   alpha=0.3, s=10, color='steelblue')
+        ax3.set_xlabel(most_correlated_feature)
+        ax3.set_ylabel('Preço ($)')
+        ax3.set_title(f'Preço vs {most_correlated_feature}\n(Corr: {top_corr.iloc[0]:.3f})')
+        ax3.grid(True, alpha=0.3)
+        
+        # Adicionar linha de tendência
+        z = np.polyfit(predictor.df[most_correlated_feature], predictor.df['price'], 1)
+        p = np.poly1d(z)
+        ax3.plot(predictor.df[most_correlated_feature], p(predictor.df[most_correlated_feature]), 
+                "r--", linewidth=2, alpha=0.8)
+        
+        return fig1, fig2, fig3
+        
+    except Exception as e:
+        print(f"Erro ao criar gráficos: {e}")
+        return None, None, None
+
+# Interface Gradio
+with gr.Blocks(theme=gr.themes.Soft(), title="Previsão de Preços de Imóveis") as demo:
+    gr.Markdown(
+        """
+        # 🏠 Previsão de Preços de Imóveis - King County
+        
+        Este aplicativo utiliza machine learning para prever preços de imóveis baseado em suas características.
+        O modelo é treinado com dados reais de King County, Washington, USA.
+        """
+    )
+    
+    with gr.Tab("📊 Carregar Dados e Treinar"):
+        with gr.Row():
+            with gr.Column():
+                file_input = gr.File(
+                    label="Upload do CSV",
+                    file_types=[".csv"],
+                    type="filepath"
+                )
+                load_btn = gr.Button("📂 Carregar Dados", variant="primary")
+            
+            with gr.Column():
+                load_status = gr.Markdown("Aguardando upload do arquivo CSV...")
+                train_btn = gr.Button("🤖 Treinar Modelo", variant="primary", visible=False)
+        
+        with gr.Row():
+            train_output = gr.Markdown("")
+            metrics_json = gr.JSON(label="Métricas Detalhadas", visible=False)
+        
+        # Conectar eventos
+        load_btn.click(
+            load_data,
+            inputs=[file_input],
+            outputs=[load_status, train_btn]
+        )
+        
+        train_btn.click(
+            train_model_action,
+            outputs=[train_output, metrics_json, metrics_json]
+        )
+    
+    with gr.Tab("🔍 Análise Exploratória"):
+        gr.Markdown("### Análise Exploratória dos Dados")
+        analysis_btn = gr.Button("📈 Gerar Análises", variant="primary")
+        
+        with gr.Row():
+            plot1 = gr.Plot(label="Distribuição de Preços")
+            plot2 = gr.Plot(label="Features Mais Correlacionadas")
+        
+        plot3 = gr.Plot(label="Relação com Feature Mais Importante")
+        
+        analysis_btn.click(
+            create_analysis_plots,
+            outputs=[plot1, plot2, plot3]
+        )
+    
+    with gr.Tab("🎯 Fazer Previsão"):
+        gr.Markdown("### Faça uma Previsão de Preço")
+        
+        with gr.Row():
+            with gr.Column():
+                prediction_inputs = gr.Column(visible=False)
+                predict_btn = gr.Button("💰 Prever Preço", variant="primary")
+            
+            with gr.Column():
+                prediction_output = gr.Markdown("Preencha os valores das características e clique em 'Prever Preço'")
+                price_display = gr.Number(
+                    label="Preço Previsto ($)",
+                    visible=False
+                )
+        
+        # Atualizar interface de previsão quando o modelo for treinado
+        def update_prediction_interface(metrics_result):
+            inputs = create_prediction_interface(metrics_result)
+            return gr.update(visible=True, value=inputs) if inputs else gr.update(visible=False)
+        
+        metrics_json.change(
+            update_prediction_interface,
+            inputs=[metrics_json],
+            outputs=[prediction_inputs]
+        )
+        
+        # Conectar botão de previsão
+        predict_btn.click(
+            predict_price_action,
+            inputs=[prediction_inputs],
+            outputs=[prediction_output, price_display]
+        ).then(
+            lambda: gr.update(visible=True),
+            outputs=[price_display]
+        )
+    
+    with gr.Tab("ℹ️ Sobre"):
+        gr.Markdown(
+            """
+            ## Sobre este Projeto
+            
+            ### 📋 Descrição
+            Este aplicativo implementa um modelo de Regressão Linear para prever preços de imóveis
+            baseado no dataset "House Sales in King County, USA".
+            
+            ### 🛠️ Tecnologias Utilizadas
+            - **Python** com scikit-learn para machine learning
+            - **Gradio** para interface web
+            - **Pandas** e **NumPy** para manipulação de dados
+            - **Matplotlib** e **Seaborn** para visualizações
+            
+            ### 📊 Características do Modelo
+            - **Algoritmo**: Regressão Linear Múltipla
+            - **Pré-processamento**: Padronização de features e transformação logarítmica do target
+            - **Validação**: Divisão 80/20 treino/teste
+            - **Métricas**: R², RMSE, MAE
+            
+            ### 🎯 Features Utilizadas
+            O modelo considera diversas características dos imóveis como:
+            - Área construída
+            - Número de quartos e banheiros
+            - Localização (latitude/longitude)
+            - Condição e qualidade do imóvel
+            - Ano de construção e renovação
+            - E outras características relevantes
+            
+            ### 📝 Notas Importantes
+            - Os resultados são estimativas baseadas em padrões históricos
+            - Fatores externos não capturados pelo modelo podem influenciar os preços reais
+            - Recomenda-se usar como ferramenta auxiliar na tomada de decisão
+            """
+        )
+
+# Para executar localmente (descomente se quiser testar)
+# if __name__ == "__main__":
+#     demo.launch(share=True)
+
+# Para Hugging Face Spaces
+demo.launch()