Regressão Linear com Scikit-learn

Introdução

Neste laboratório, você aprenderá os fundamentos da construção de um modelo de machine learning utilizando uma das bibliotecas Python mais populares, scikit-learn. Focaremos em Regressão Linear, um algoritmo básico, porém poderoso, usado para prever um valor contínuo, como um preço ou uma temperatura.

Nosso objetivo é construir um modelo que possa prever os preços medianos de imóveis em distritos da Califórnia. Utilizaremos o conjunto de dados de imóveis da Califórnia, que está convenientemente incluído com scikit-learn.

Ao longo deste laboratório, você aprenderá a:

• Carregar um conjunto de dados do scikit-learn.
• Preparar e dividir os dados para treinamento e teste.
• Criar e treinar um modelo de Regressão Linear.
• Usar o modelo treinado para fazer previsões.

Você realizará todas as tarefas dentro do WebIDE. Vamos começar!

Carregar o conjunto de dados de habitação da Califórnia com datasets.fetch_california_housing()

Nesta etapa, começaremos carregando o conjunto de dados para o nosso modelo. O scikit-learn vem com vários conjuntos de dados integrados, que são ótimos para aprendizado e prática. Utilizaremos o conjunto de dados de imóveis da Califórnia.

Primeiro, precisamos criar um script Python. Um arquivo chamado main.py já foi criado para você no diretório ~/project. Você pode encontrá-lo no explorador de arquivos no lado esquerdo do WebIDE.

Abra main.py e adicione o seguinte código. Este código importa as bibliotecas necessárias (fetch_california_housing de sklearn.datasets e pandas) e carrega o conjunto de dados. Usaremos o pandas para converter os dados em um DataFrame, que é uma estrutura de dados tabular fácil de visualizar e manipular.

Por favor, adicione o seguinte código a main.py:

import pandas as pd
from sklearn.datasets import fetch_california_housing

## Load the California housing dataset
california = fetch_california_housing()

## Create a DataFrame
california_df = pd.DataFrame(california.data, columns=california.feature_names)
california_df['MedHouseVal'] = california.target

## Print the first 5 rows of the DataFrame
print("California Housing Dataset:")
print(california_df.head())

Agora, vamos executar o script para ver a saída. Abra um terminal no WebIDE (você pode usar o menu "Terminal" -> "New Terminal") e execute o seguinte comando:

python3 main.py

Você deverá ver as primeiras cinco linhas do conjunto de dados impressas no console. A coluna MedHouseVal é a nossa variável alvo, representando o valor mediano das casas para distritos da Califórnia, expresso em centenas de milhares de dólares ($100.000).

California Housing Dataset:
   MedInc  HouseAge  AveRooms  AveBedrms  Population  AveOccup  Latitude  Longitude  MedHouseVal
0  8.3252      41.0  6.984127   1.023810       322.0  2.555556     37.88    -122.23        4.526
1  8.3014      21.0  6.238137   0.971880      2401.0  2.109842     37.86    -122.22        3.585
2  7.2574      52.0  8.288136   1.073446       496.0  2.802260     37.85    -122.24        3.521
3  5.6431      52.0  5.817352   1.073059       558.0  2.547945     37.85    -122.25        3.413
4  3.8462      52.0  6.281853   1.081081       565.0  2.181467     37.85    -122.25        3.422

Dividir os dados em treino e teste usando train_test_split de sklearn.model_selection

Nesta etapa, prepararemos nossos dados para o processo de treinamento. Uma parte crucial do machine learning é avaliar o modelo em dados que ele nunca viu antes. Para fazer isso, dividimos nosso conjunto de dados em duas partes: um conjunto de treinamento e um conjunto de teste. O modelo aprenderá com o conjunto de treinamento, e usaremos o conjunto de teste para ver o quão bem ele se sai.

Primeiro, precisamos separar nossas features (as variáveis de entrada, X) do nosso target (o valor que queremos prever, y). No nosso caso, X serão todas as colunas, exceto MedHouseVal, e y será a coluna MedHouseVal.

Em seguida, usaremos a função train_test_split de sklearn.model_selection para realizar a divisão.

Adicione o seguinte código ao seu arquivo main.py.

from sklearn.model_selection import train_test_split

## Prepare the data
X = california_df.drop('MedHouseVal', axis=1)  ## Features (input variables)
y = california_df['MedHouseVal']  ## Target variable (what we want to predict)

## Split the data into training and testing sets
## test_size=0.2: Reserve 20% of data for testing, 80% for training
## random_state=42: Ensures reproducible splits (same result every run)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

## Print the shapes of the new datasets to confirm the split
print("\n--- Data Split ---")
print("X_train shape:", X_train.shape)  ## Training features
print("X_test shape:", X_test.shape)    ## Test features
print("y_train shape:", y_train.shape)  ## Training target values
print("y_test shape:", y_test.shape)    ## Test target values

Agora, execute o script novamente a partir do terminal:

python3 main.py

Você verá as formas dos conjuntos de treinamento e teste recém-criados impressas abaixo do DataFrame. Isso confirma que os dados foram divididos corretamente.

--- Data Split ---
X_train shape: (16512, 8)
X_test shape: (4128, 8)
y_train shape: (16512,)
y_test shape: (4128,)

Inicializar o modelo LinearRegression de sklearn.linear_model

Nesta etapa, criaremos nosso modelo de Regressão Linear. O scikit-learn torna isso incrivelmente simples. Precisamos apenas importar a classe LinearRegression do módulo sklearn.linear_model e, em seguida, criar uma instância dela.

Esta instância é um objeto que contém o algoritmo de regressão linear. A regressão linear encontra a linha de melhor ajuste através dos pontos de dados, usando a fórmula: y = mx + b, onde m são os coeficientes (pesos) para cada característica, e b é a interceptação. Aqui usamos parâmetros padrão que funcionam bem para a maioria dos casos básicos.

Figura 1: Fórmula de regressão linear y = mx + b, onde m é a inclinação e b é a interceptação

Anexe o seguinte código ao seu arquivo main.py. Isso importará a classe LinearRegression e criará um objeto de modelo.

from sklearn.linear_model import LinearRegression

## Inicializar o modelo de Regressão Linear
model = LinearRegression()

## Imprimir o modelo para confirmar que ele foi criado
print("\n--- Modelo Inicializado ---")
print(model)

Execute seu script main.py novamente a partir do terminal:

python3 main.py

A saída agora incluirá uma linha mostrando o objeto LinearRegression. Isso confirma que o modelo foi inicializado com sucesso.

--- Modelo Inicializado ---
LinearRegression()

Ajustar o modelo com model.fit(X_train, y_train)

Nesta etapa, treinaremos nosso modelo. Este processo é frequentemente chamado de "ajustar" (fitting) o modelo aos dados. Durante o ajuste, o modelo aprende as relações entre as features (X_train) e a variável target (y_train). Para regressão linear, isso significa encontrar os coeficientes ótimos para cada feature para prever melhor o target.

Usaremos o método fit() do nosso objeto de modelo, passando nossos dados de treinamento como argumentos.

Adicione o seguinte código ao seu arquivo main.py.

## Fit (train) the model on the training data
## The fit() method learns the relationship between features (X_train) and target (y_train)
## It calculates optimal coefficients for each feature and the intercept using least squares optimization
model.fit(X_train, y_train)

## After fitting, the model has learned the coefficients and intercept.
## The intercept represents the predicted value when all features are zero
print("\n--- Model Trained ---")
print("Intercept:", model.intercept_)

Agora, execute o script a partir do terminal:

python3 main.py

Após a execução do script, você verá uma nova seção na saída mostrando o intercepto do modelo de regressão linear. O intercepto é o valor da previsão quando todos os valores das features são zero. Ver um valor numérico aqui confirma que o modelo foi treinado com sucesso nos dados.

--- Model Trained ---
Intercept: -37.023277706064185

Prever nos dados de teste com model.predict(X_test)

Nesta etapa final, usaremos nosso modelo treinado para fazer previsões. Este é o objetivo final de construir um modelo preditivo. Usaremos os dados de teste (X_test), que o modelo não viu durante o treinamento, para avaliar seu desempenho.

Usaremos o método predict() do nosso objeto de modelo treinado, passando as features de teste (X_test) como argumento. O método retornará um array de valores previstos para a variável target.

Adicione o seguinte código ao seu arquivo main.py.

## Make predictions on the test data
## The predict() method uses the learned coefficients and intercept to calculate predictions
## Formula: prediction = intercept + (coeff1 * feature1) + (coeff2 * feature2) + ...
predictions = model.predict(X_test)

## Print the first 5 predictions (values are in $100,000 units)
print("\n--- Predictions ---")
print(predictions[:5])

Agora, execute o script completo uma última vez a partir do terminal:

python3 main.py

A saída agora incluirá as cinco primeiras previsões de preços de casas para o conjunto de teste. Esses valores são o que nosso modelo acredita que deveriam ser os valores medianos das casas, com base nas features em X_test. Você pode comparar conceitualmente essas previsões com os valores reais em y_test para avaliar a precisão do modelo.

--- Predictions ---
[0.71912284 1.76401657 2.70965883 2.83892593 2.60465725]

Parabéns! Você construiu, treinou e utilizou com sucesso um modelo de regressão linear com scikit-learn.

Resumo

Neste laboratório, você completou todo o fluxo de trabalho para construir um modelo básico de machine learning usando scikit-learn.

Você começou carregando o conjunto de dados de habitação da Califórnia e o preparando usando pandas. Em seguida, aprendeu a importância de dividir seus dados em conjuntos de treinamento e teste e realizou a divisão usando train_test_split.

Depois disso, você inicializou um modelo LinearRegression, treinou-o em seus dados de treinamento usando o método fit(), e finalmente usou o modelo treinado para fazer previsões em dados de teste não vistos com o método predict().

Este laboratório fornece uma base sólida em scikit-learn. A partir daqui, você pode explorar tópicos mais avançados, como:

• Avaliação do modelo: Calcular métricas como Erro Quadrático Médio (MSE) ou R-squared para medir a precisão do modelo
• Escalonamento de features: Padronizar ou normalizar features para melhor desempenho
• Regularização: Usar regressão Ridge ou Lasso para evitar overfitting
• Validação cruzada: Avaliação mais robusta usando validação cruzada k-fold
• Outros algoritmos: Experimentar Random Forest, Support Vector Machines ou Redes Neurais

Summary

In this lab, you have completed the entire workflow for building a basic machine learning model using scikit-learn.

You started by loading the California housing dataset and preparing it using pandas. Then, you learned the importance of splitting your data into training and testing sets and performed the split using train_test_split.

Following that, you initialized a LinearRegression model, trained it on your training data using the fit() method, used the trained model to make predictions on unseen test data with the predict() method, and finally visualized the results to understand your model's performance.

This lab provides a solid foundation in scikit-learn. From here, you can explore more advanced topics such as:

• Model evaluation: Calculate metrics like Mean Squared Error (MSE) or R-squared to measure model accuracy
• Data visualization: Create more advanced plots like residual plots, feature importance charts, or correlation matrices
• Feature scaling: Standardize or normalize features for better performance
• Regularization: Use Ridge or Lasso regression to prevent overfitting
• Cross-validation: More robust evaluation using k-fold cross-validation
• Other algorithms: Try Random Forest, Support Vector Machines, or Neural Networks