Lære Lineær Regression

Vi vil bruge et rigtigt datasæt til at implementere lineær regression i PyTorch. Datasættet indeholder to kolonner:

'Number of Appliances': antallet af apparater i en husstand (inputfunktion, X);
'Electricity Bill': det tilsvarende elregningsbeløb (måloutput, Y).

1. Indlæsning og inspektion af datasættet

Datasættet er gemt i en CSV-fil. Vi indlæser det med pandas og inspicerer de første par rækker:


              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. Forberedelse af data til PyTorch

Dernæst skal vi udtrække inputkolonnen X og målkolonnen Y, konvertere dem til PyTorch-tensorer og omforme dem til 2D-tensorer for at sikre kompatibilitet med PyTorchs operationer:


              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. Definition af den lineære model

Modulet nn.Linear i PyTorch definerer et fuldt forbundet lag, der udfører y = xWT + b. Det er en grundlæggende byggesten i neurale netværk og kan kombineres med andre lag for mere komplekse arkitekturer.

Dets vigtigste parametre er som følger:

in_features: antal inputfunktioner (uafhængige variabler);
out_features: antal outputfunktioner (forudsagte værdier).

For simpel lineær regression, som i dette tilfælde, forudsiges en enkelt output baseret på én input. Derfor:

in_features=1: én inputvariabel;
out_features=1: én forudsagt værdi.

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

4. Definition af tabfunktion og optimeringsalgoritme

Vi anvender mean squared error (MSE) som tabfunktion og stochastic gradient descent (SGD) som optimeringsalgoritme med en læringsrate sat til 0.005.

MSE-tab kan defineres ved brug af nn.MSELoss-klassen, og SGD ved brug af den tilsvarende klasse fra torch.optim-modulet.

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. Træning af modellen

Træning indebærer udførelse af et fremadrettet pass og et bagudrettet pass for et specificeret antal epoker.

Fremadrettet pass: dette trin beregner modellens forudsigelser baseret på inputdata og beregner tabet ved at sammenligne forudsigelserne med de faktiske målværdier;
Bagudrettet pass: dette trin beregner gradienter ved hjælp af backpropagation (baseret på tabet) og opdaterer modellens vægte og bias ved hjælp af en optimeringsalgoritme, som i dette tilfælde er SGD.

Denne proces gentages for det angivne antal epoker for at minimere tabet og forbedre modellens ydeevne.


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

Parametrene for modellen, nemlig dens vægte og bias, kan tilgås ved hjælp af attributterne .weight og .bias:

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

Bemærk

optimizer.zero_grad() er vigtig, fordi den nulstiller gradienterne for alle parametre før backpropagation. Uden dette trin ville gradienterne akkumulere fra tidligere trin, hvilket ville føre til forkerte opdateringer af modellens vægte. Dette sikrer, at hver bagudpassage starter med et rent udgangspunkt.

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 13

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Stryg for at vise menuen