Este artigo explora a implementação da regressão linear usando o framework PyTorch. Abordaremos desde a preparação dos dados até o treinamento do modelo, destacando conceitos-chave da biblioteca.

A regressão linear é um método fundamental para modelar a relação entre uma variável dependente contínua e uma ou mais variáveis independentes. A formulação matemática básica pode ser expressa como:

A manipulação de tensores é operações básicas são cruciais para trabalhar com o PyTorch. A função torch.unsqueeze altera a dimensionalidade de um tensor, adicionando uma dimensão na posição especificada:

tensor_original = torch.tensor([1, 2, 3])
tensor_alterado = torch.unsqueeze(tensor_original, dim=0)  # Adiciona dimensão na posição 0

Para gerar dados distribuídos uniformemente em um intervalo, utilize torch.linspace, que cria uma sequência de valores igualmente espaçados:

pontos = torch.linspace(start=0.0, end=10.0, steps=20)

A camada torch.nn.Linear(in_features, out_features) implementa a transformação linear. Para uma regressão simples, usamos Linear(1, 1), que mantém dois parâmetros treináveis: um peso (weight) e um viés (bias). A operação realizada é:

O código a seguir demonstra a criação e treinamento de um modelo de regressão linear. Observe a estrutura da rede neural simplificada e o processo de otimização.

import torch

# Hiperparâmetros
epocas = 5000
taxa_aprendizado = 0.02

# Gerando dados sintéticos
caracteristicas = torch.unsqueeze(torch.linspace(1, 8, 25), dim=1)
alvos = 3.5 * caracteristicas + 2.8 + torch.randn(caracteristicas.size()) * 0.5

# Definição do modelo
class ModeloRegressao(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.camada_linear = torch.nn.Linear(1, 1)
    
    def forward(self, entrada):
        previsao = self.camada_linear(entrada)
        return previsao

# Instanciação
modelo = ModeloRegressao()
otimizador = torch.optim.SGD(modelo.parameters(), lr=taxa_aprendizado)
funcao_perda = torch.nn.MSELoss()

# Loop de treinamento
for epoca in range(epocas):
    saidas_previstas = modelo(caracteristicas)
    perda = funcao_perda(saidas_previstas, alvos)
    
    otimizador.zero_grad()
    perda.backward()
    otimizador.step()
    
    if epoca % 1000 == 0:
        print(f'Época {epoca}, Perda: {perda.item():.4f}')

# Resultados finais
print("\nPesos treinados:", modelo.camada_linear.weight.data)
print("Viés treinado:", modelo.camada_linear.bias.data)
print("Perda final:", perda.item())

Análise dos Resultados

Ao executar o código, o modelo aprende a aproximar a relação linear presente nos dados. Os valores dos parâmetros treinados devem convergir para os valores reais utilizados na geração dos dados (peso ≈ 3.5, viés ≈ 2.8), com uma perda relativamente baixa devido ao ruído adicionado.

A precisão da aproximação depende de vários fatores, incluindo a taxa de aprendizado, o número de épocas e a quantidade de dados disponíveis. É importante monitorar a perda durante o treinamento para garantir a convergência do modelo e evitar tanto o underfitting quanto o overfittting.