Leer Lineaire Regressie

We gebruiken een echte dataset om lineaire regressie in PyTorch te implementeren. De dataset bevat twee kolommen:

'Number of Appliances': het aantal apparaten in een huishouden (invoerfeature, X);
'Electricity Bill': het bijbehorende bedrag van de elektriciteitsrekening (doeluitvoer, Y).

1. Laden en Inspecteren van de Dataset

De dataset is opgeslagen in een CSV-bestand. We laden deze met pandas en inspecteren de eerste paar rijen:


              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. De gegevens voorbereiden voor PyTorch

Vervolgens moeten we de inputkolom X en de doeldatkolom Y extraheren, deze omzetten naar PyTorch-tensors en omvormen tot 2D-tensors om compatibiliteit met PyTorch-operaties te garanderen:


              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. Het lineaire model definiëren

De nn.Linear-module in PyTorch definieert een volledig verbonden laag die y = xWT + b uitvoert. Dit is een fundamenteel bouwblok in neurale netwerken en kan worden gecombineerd met andere lagen voor complexere architecturen.

De belangrijkste parameters zijn als volgt:

in_features: aantal invoerkenmerken (onafhankelijke variabelen);
out_features: aantal uitvoerkenmerken (voorspelde waarden).

Voor eenvoudige lineaire regressie, zoals in ons geval, voorspellen we één output op basis van één input. Dus:

in_features=1: één invoervariabele;
out_features=1: één voorspelde waarde.

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

4. Definiëren van de verliesfunctie en optimizer

We gebruiken mean squared error (MSE) als verliesfunctie en stochastic gradient descent (SGD) als optimizer met een leersnelheid van 0.005.

De MSE-verliesfunctie kan worden gedefinieerd met de nn.MSELoss-klasse en SGD met de respectievelijke klasse uit de torch.optim-module.

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. Het model trainen

Training omvat het uitvoeren van een forward pass en een backward pass voor een opgegeven aantal epochs.

Forward pass: deze stap bepaalt de voorspellingen van het model op basis van de invoergegevens en berekent het verlies door de voorspellingen te vergelijken met de werkelijke doelwaarden;
Backward pass: deze stap berekent de gradiënten met behulp van backpropagation (gebaseerd op het verlies) en werkt de gewichten en biases van het model bij met behulp van een optimalisatie-algoritme, in dit geval SGD.

Dit proces wordt herhaald voor het opgegeven aantal epochs om het verlies te minimaliseren en de prestaties van het model te verbeteren.


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

De parameters van het model, namelijk de gewichten en biases, zijn toegankelijk via de attributen .weight en .bias:

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

Opmerking

optimizer.zero_grad() is belangrijk omdat het de gradiënten van alle parameters reset vóór backpropagation. Zonder deze stap zouden gradiënten ophopen van eerdere stappen, wat leidt tot onjuiste updates van de gewichten van het model. Dit zorgt ervoor dat elke backward pass met een schone lei begint.

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 1. Hoofdstuk 13

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Veeg om het menu te tonen