Lære Lineær Regression

Stryg for at vise menuen

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

'Number of Appliances': antal apparater i en husstand (input-feature, X);
'Electricity Bill': den tilsvarende elregning (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 inputkolonnen X og målkolonnen Y udtrækkes, konverteres til PyTorch-tensorer og omformes til 2D-tensorer for at sikre kompatibilitet med PyTorch-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:

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

Ved 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 hjælp af nn.MSELoss-klassen, og SGD ved hjælp 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 forward pass og et backward pass for et angivet antal epoker.

Forward pass: dette trin beregner modellens forudsigelser baseret på inputdata og beregner tabet ved at sammenligne forudsigelserne med de faktiske målværdier;
Backward 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 biases, 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 backward-pass 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

Sektion 1. Kapitel 13