O aprendizado de máquina está transformando vários setores, incluindo o imobiliário. Uma tarefa comum é prever os preços das casas com base em vários recursos, como número de quartos, banheiros, metragem quadrada e localização. Neste artigo, exploraremos como construir um modelo de aprendizado de máquina usando scikit-learn para prever preços de casas, cobrindo todos os aspectos, desde o pré-processamento de dados até a implantação do modelo.

Índice

1. Introdução ao Scikit-learn
2. Definição do problema
3. Coleta de dados
4. Pré-processamento de dados
5. Seleção de recursos
6. Treinamento de modelo
7. Avaliação do modelo
8. Ajuste de modelo (otimização de hiperparâmetros)
9. Implantação de modelo
10. Conclusão

1. Introdução ao Scikit-learn

Scikit-learn é uma das bibliotecas mais usadas para aprendizado de máquina em Python. Oferece ferramentas simples e eficientes para análise e modelagem de dados. Esteja você lidando com classificação, regressão, clustering ou redução de dimensionalidade, o scikit-learn fornece um amplo conjunto de utilitários para ajudá-lo a construir modelos robustos de aprendizado de máquina.

Neste guia, construiremos um modelo de regressão usando o scikit-learn para prever preços de imóveis. Vamos percorrer cada etapa do processo.

2. Definição do Problema

A tarefa em questão é prever o preço de uma casa com base em suas características, como:

• Número de quartos
• Número de banheiros
• Área (em pés quadrados)
• Localização

Este é um problema de aprendizagem supervisionada onde a variável alvo (preço da casa) é contínua, tornando-o uma tarefa de regressão. Scikit-learn fornece uma variedade de algoritmos para regressão, como Regressão Linear e Floresta Aleatória, que usaremos neste projeto.

3. Coleta de dados

Você pode usar um conjunto de dados do mundo real, como o conjunto de dados Kaggle House Prices, ou coletar seus próprios dados de uma API pública.

Veja um exemplo da aparência dos seus dados:

A variável alvo aqui é o Preço.

4. Pré-processamento de dados

Antes de alimentar os dados em um modelo de aprendizado de máquina, precisamos pré-processá-los. Isso inclui lidar com valores ausentes, codificar recursos categóricos e dimensionar os dados.

Tratamento de dados ausentes

Dados ausentes são comuns em conjuntos de dados do mundo real. Podemos preencher os valores ausentes com uma medida estatística como a mediana ou eliminar linhas com dados ausentes:

data.fillna(data.median(), inplace=True)

Codificando recursos categóricos

Como os modelos de aprendizado de máquina exigem entrada numérica, precisamos converter recursos categóricos como Localização em números. Codificação de rótulo atribui um número exclusivo a cada categoria:

from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
data['Location'] = encoder.fit_transform(data['Location'])

Dimensionamento de recursos

É importante dimensionar recursos como Área e Preço para garantir que eles estejam na mesma escala, especialmente para algoritmos sensíveis à magnitude do recurso. Veja como aplicamos o dimensionamento:

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

5. Seleção de recursos

Nem todos os recursos contribuem igualmente para a variável de destino. A seleção de recursos ajuda a identificar os recursos mais importantes, o que melhora o desempenho do modelo e reduz o overfitting.

Neste projeto, usamos SelectKBest para selecionar os 5 principais recursos com base em sua correlação com a variável de destino:

from sklearn.feature_selection import SelectKBest, f_regression
selector = SelectKBest(score_func=f_regression, k=5)
X_new = selector.fit_transform(X, y)

6. Treinamento de modelo

Agora que pré-processamos os dados e selecionamos os melhores recursos, é hora de treinar o modelo. Usaremos dois algoritmos de regressão: Regressão Linear e Floresta Aleatória.

Regressão Linear

A regressão linear ajusta uma linha reta através dos dados, minimizando a diferença entre os valores previstos e reais:

from sklearn.linear_model import LinearRegression
linear_model = LinearRegression()
linear_model.fit(X_train, y_train)

Floresta Aleatória

Random Forest é um método conjunto que usa múltiplas árvores de decisão e calcula a média de seus resultados para melhorar a precisão e reduzir o overfitting:

from sklearn.ensemble import RandomForestRegressor
forest_model = RandomForestRegressor(n_estimators=100)
forest_model.fit(X_train, y_train)

Divisão de teste de trem

Para avaliar quão bem nossos modelos são generalizados, dividimos os dados em conjuntos de treinamento e teste:

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_new, y, test_size=0.2, random_state=42)

7. Avaliação do modelo

Depois de treinar os modelos, precisamos avaliar seu desempenho usando métricas como Erro Quadrático Médio (MSE) e R-quadrado (R²).

Erro Quadrático Médio (MSE)

MSE calcula a diferença quadrática média entre os valores previstos e reais. Um MSE mais baixo indica melhor desempenho:

from sklearn.metrics import mean_squared_error
mse = mean_squared_error(y_test, y_pred)

R-quadrado (R²)

R² nos diz quão bem o modelo explica a variação na variável alvo. Um valor de 1 significa previsão perfeita:

from sklearn.metrics import r2_score
r2 = r2_score(y_test, y_pred)

Compare o desempenho dos modelos de regressão linear e floresta aleatória usando essas métricas.

8. Ajuste de modelo (otimização de hiperparâmetros)

Para melhorar ainda mais o desempenho do modelo, podemos ajustar os hiperparâmetros. Para Random Forest, hiperparâmetros como n_estimators (número de árvores) e max_profundidade (profundidade máxima das árvores) podem impactar significativamente o desempenho.

Veja como usar GridSearchCV para otimização de hiperparâmetros:

from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20]
}

grid_search = GridSearchCV(RandomForestRegressor(), param_grid, cv=5)
grid_search.fit(X_train, y_train)

best_model = grid_search.best_estimator_

9. Implantação do modelo

Depois de treinar e ajustar o modelo, a próxima etapa é a implantação. Você pode usar o Flask para criar um aplicativo da web simples que serve previsões.

Aqui está um aplicativo Flask básico para fornecer previsões de preços de casas:

from flask import Flask, request, jsonify
import joblib

app = Flask(__name__)

# Load the trained model
model = joblib.load('best_model.pkl')

@app.route('/predict', methods=['POST'])
def predict():
    data = request.json
    prediction = model.predict([data['features']])
    return jsonify({'predicted_price': prediction[0]})

if __name__ == '__main__':
    app.run()

Salve o modelo treinado usando joblib:

import joblib
joblib.dump(best_model, 'best_model.pkl')

Dessa forma, você pode fazer previsões enviando solicitações à API.

10. Conclusão

Neste projeto, exploramos todo o processo de construção de um modelo de aprendizado de máquina usando o scikit-learn para prever preços de imóveis. Desde o pré-processamento de dados e seleção de recursos até o treinamento, avaliação e implantação do modelo, cada etapa foi abordada com exemplos práticos de código.

Se você é novo no aprendizado de máquina ou deseja aplicar o scikit-learn em projetos do mundo real, este guia fornece um fluxo de trabalho abrangente que você pode adaptar para várias tarefas de regressão.

Sinta-se à vontade para experimentar diferentes modelos, conjuntos de dados e técnicas para melhorar o desempenho e a precisão do seu modelo.

Regressão #AI #Análise de Dados #Pré-processamento de Dados #ModeloML #FlorestaRandom #RegressãoLinear #Flask #APIDevelopment #RealEstate #TechBlog #Tutorial #Engenharia de Dados #DeepLearning #Análise Preditiva #DevCommunity