Impara Regressione Lineare | Concetti Più Avanzati

Utilizzeremo un dataset reale per implementare la regressione lineare in PyTorch. Il dataset contiene due colonne:

'Number of Appliances': il numero di elettrodomestici in una famiglia (caratteristica di input, X);
'Electricity Bill': l'importo corrispondente della bolletta elettrica (output target, Y).

1. Caricamento e Ispezione del Dataset

Il dataset è memorizzato in un file CSV. Lo caricheremo utilizzando pandas e ne ispezioneremo le prime righe:


              12345
            
import pandas as pd
# Load the dataset
bills_df = pd.read_csv('https://content-media-cdn.codefinity.com/courses/1dd2b0f6-6ec0-40e6-a570-ed0ac2209666/section_2/electricity_bills.csv')
# Display the first five rows
print(bills_df.head())

2. Preparazione dei dati per PyTorch

Successivamente, è necessario estrarre le colonne di input X e target Y, convertirle in tensori PyTorch e rimodellarle in tensori 2D per garantire la compatibilità con le operazioni di PyTorch:


              12345678910
            
import torch
import pandas as pd
# Load the dataset
bills_df = pd.read_csv('https://content-media-cdn.codefinity.com/courses/1dd2b0f6-6ec0-40e6-a570-ed0ac2209666/section_2/electricity_bills.csv')
# Extract input (Number of Appliances) and target (Electricity Bill)
X = torch.tensor(bills_df['Number of Appliances'].values).float().reshape(-1, 1)
Y = torch.tensor(bills_df['Electricity Bill'].values).float().reshape(-1, 1)
# Print the shapes of X and Y
print(f"Shape of X: {X.shape}")
print(f"Shape of Y: {Y.shape}")

3. Definizione del modello lineare

Il modulo nn.Linear in PyTorch definisce un layer completamente connesso, eseguendo y = xWT + b. Si tratta di un elemento fondamentale nelle reti neurali e può essere combinato con altri layer per architetture più complesse.

I suoi parametri principali sono i seguenti:

in_features: numero di feature in ingresso (variabili indipendenti);
out_features: numero di feature in uscita (valori previsti).

Per la regressione lineare semplice, come nel nostro caso, si prevede un singolo output a partire da un input. Quindi:

in_features=1: una variabile in ingresso;
out_features=1: un valore previsto.

import torch.nn as nn
# Define the linear regression model
model = nn.Linear(in_features=1, out_features=1)

4. Definizione della Funzione di Perdita e dell'Ottimizzatore

Utilizzeremo la mean squared error (MSE) come funzione di perdita e la stochastic gradient descent (SGD) come ottimizzatore, con un learning rate pari a 0.005.

La perdita MSE può essere definita utilizzando la classe nn.MSELoss, mentre SGD tramite la rispettiva classe del modulo torch.optim.

import torch.optim as optim
# Define the loss function (MSE)
loss_fn = nn.MSELoss()
# Define the optimizer (SGD)
optimizer = optim.SGD(model.parameters(), lr=0.005)

5. Addestramento del Modello

L'addestramento consiste nell'eseguire un forward pass e un backward pass per un numero specificato di epoche.

Forward pass: questa fase calcola le predizioni del modello in base ai dati di input e calcola la perdita confrontando le predizioni con i valori target reali;
Backward pass: questa fase calcola i gradienti utilizzando la backpropagation (basata sulla perdita) e aggiorna i pesi e i bias del modello utilizzando un algoritmo di ottimizzazione, che in questo caso è SGD.

Questo processo si ripete per il numero specificato di epoche al fine di minimizzare la perdita e migliorare le prestazioni del modello.


              1234567891011121314151617181920212223242526272829303132333435
            
import torch
import torch.nn as nn
import torch.optim as optim
import pandas as pd
# Load the dataset
bills_df = pd.read_csv('https://staging-content-media-cdn.codefinity.com/courses/1dd2b0f6-6ec0-40e6-a570-ed0ac2209666/section_2/electricity_bills.csv')
# Extract input (Number of Appliances) and target (Electricity Bill)
X = torch.tensor(bills_df['Number of Appliances'].values).float().reshape(-1, 1)
Y = torch.tensor(bills_df['Electricity Bill'].values).float().reshape(-1, 1)
# Define the linear regression model
model = nn.Linear(in_features=1, out_features=1)
# Define the loss function (MSE)
loss_fn = nn.MSELoss()
# Define the optimizer (SGD)
optimizer = optim.SGD(model.parameters(), lr=0.005)
# Training loop
epochs = 100
for epoch in range(epochs):
    # Forward pass
    Y_pred = model(X)
    loss = loss_fn(Y_pred, Y)

    # Backward pass
    optimizer.zero_grad()  # Reset gradients
    loss.backward()        # Compute gradients

    # Update parameters
    optimizer.step()

    if (epoch + 1) % 10 == 0:
        print(f"Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}")

# Final parameters
print(f"Trained weight: {model.weight.item()}")
print(f"Trained bias: {model.bias.item()}")

I parametri del modello, ovvero i suoi pesi e bias, possono essere accessibili tramite gli attributi .weight e .bias:

weights = model.weight.item()
biases = model.bias.item()

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 2. Capitolo 3

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Suggested prompts:

Can you explain how the training loop works in more detail?

What do the trained weight and bias values represent?

How can I use this trained model to make predictions on new data?

Awesome!

Completion rate improved to 5

Scorri per mostrare il menu