Lära Linjär Regression

Vi kommer att använda en verklig datamängd för att implementera linjär regression i PyTorch. Datamängden innehåller två kolumner:

'Number of Appliances': antalet apparater i ett hushåll (inmatningsfunktion, X);
'Electricity Bill': motsvarande elräkningsbelopp (målutdata, Y).

1. Ladda och inspektera datamängden

Datamängden är lagrad i en CSV-fil. Vi laddar den med hjälp av pandas och inspekterar de första raderna:


              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. Förbereda data för PyTorch

Nästa steg är att extrahera kolumnerna för indata X och målvariabel Y, konvertera dem till PyTorch-tensorer och omforma dem till 2D-tensorer för att säkerställa 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. Definiera den linjära modellen

Modulen nn.Linear i PyTorch definierar ett fullt anslutet lager som utför y = xWT + b. Det är en grundläggande byggsten i neurala nätverk och kan kombineras med andra lager för mer komplexa arkitekturer.

Dess viktigaste parametrar är:

in_features: antal indatafunktioner (oberoende variabler);
out_features: antal utdatafunktioner (predikterade värden).

För enkel linjär regression, som i vårt fall, predikteras ett enda utdata baserat på en indata. Därför gäller:

in_features=1: en indata variabel;
out_features=1: ett predikterat värde.

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

4. Definiera förlustfunktionen och optimeraren

Vi använder mean squared error (MSE) som förlustfunktion och stochastic gradient descent (SGD) som optimerare med inlärningshastighet satt till 0.005.

MSE-förlusten kan definieras med klassen nn.MSELoss, och SGD med motsvarande klass från modulen 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. Träna modellen

Träning innebär att utföra en framåtriktad passering och en bakåtriktad passering under ett angivet antal epoker.

Framåtriktad passering: detta steg beräknar modellens prediktioner baserat på indata och beräknar förlusten genom att jämföra prediktionerna med de faktiska målvariablerna;
Bakåtriktad passering: detta steg beräknar gradienter med hjälp av backpropagation (baserat på förlusten) och uppdaterar modellens vikter och bias med hjälp av en optimeringsalgoritm, vilket i vårt fall är SGD.

Denna process upprepas under det angivna antalet epoker för att minimera förlusten och förbättra modellens prestanda.


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

Modellens parametrar, det vill säga dess vikter och bias, kan nås via attributen .weight och .bias:

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

Notera

optimizer.zero_grad() är viktigt eftersom det återställer gradienterna för alla parametrar före backpropagation. Utan detta steg skulle gradienterna ackumuleras från tidigare steg, vilket leder till felaktiga uppdateringar av modellens vikter. Detta säkerställer att varje bakåtriktad passering startar från noll.

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 13

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Svep för att visa menyn