Régression Linéaire

Nous utiliserons un jeu de données réel pour implémenter la régression linéaire dans PyTorch. Le jeu de données contient deux colonnes :

'Number of Appliances': le nombre d'appareils dans un ménage (caractéristique d'entrée, X);
'Electricity Bill': le montant correspondant de la facture d'électricité (sortie cible, Y).

1. Chargement et Inspection du Jeu de Données

Le jeu de données est stocké dans un fichier CSV. Nous allons le charger en utilisant pandas et inspecter les premières lignes :


              12345
            
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')
# Display the first five rows
print(bills_df.head())

2. Préparation des données pour PyTorch

Ensuite, nous devons extraire les colonnes d'entrée X et cible Y, les convertir en tenseurs PyTorch, et les remodeler en tenseurs 2D pour assurer la compatibilité avec les opérations de PyTorch :


              12345678910
            
import torch
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)
# Print the shapes of X and Y
print(f"Shape of X: {X.shape}")
print(f"Shape of Y: {Y.shape}")

3. Définition du modèle linéaire

Le module nn.Linear dans PyTorch définit une couche entièrement connectée, effectuant y = xWT + b. C'est un bloc de construction fondamental dans les réseaux neuronaux et peut être combiné avec d'autres couches pour des architectures plus complexes.

Ses paramètres clés sont les suivants :

in_features: nombre de caractéristiques d'entrée (variables indépendantes);
out_features: nombre de caractéristiques de sortie (valeurs prédites).

Pour une régression linéaire simple, comme dans notre cas, nous prédisons une seule sortie basée sur une entrée. Ainsi :

in_features=1: une variable d'entrée;
out_features=1: une valeur prédite.

4. Définir la Fonction de Perte et l'Optimiseur

Nous utiliserons l'erreur quadratique moyenne (MSE) comme fonction de perte et la descente de gradient stochastique (SGD) comme optimiseur avec un taux d'apprentissage égal à 0.005.

La perte MSE peut être définie en utilisant la classe nn.MSELoss, et SGD en utilisant la classe respective du module torch.optim.

5. Entraîner le Modèle

L'entraînement implique d'effectuer un passage avant et un passage arrière pour un nombre spécifié d'époques.

Passage avant : cette étape calcule les prédictions du modèle basées sur les données d'entrée et calcule la perte en comparant les prédictions aux valeurs cibles réelles ;
Passage arrière : cette étape calcule les gradients en utilisant la rétropropagation (basée sur la perte) et met à jour les poids et biais du modèle en utilisant un algorithme d'optimisation, qui est SGD dans notre cas.

Ce processus se répète pour le nombre spécifié d'époques afin de minimiser la perte et d'améliorer la performance du modèle.


              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()}")

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 3