Lære Lineær regresjon

Vi skal bruke et ekte datasett for å implementere lineær regresjon i PyTorch. Datasettet inneholder to kolonner:

'Number of Appliances': antall apparater i en husholdning (inndatafunksjon, X);
'Electricity Bill': tilhørende strømregning (målvariabel, Y).

1. Laste inn og inspisere datasettet

Datasettet er lagret i en CSV-fil. Vi laster det inn med pandas og inspiserer de første radene:


              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 av data for PyTorch

Deretter bør vi hente ut kolonnene for input X og mål Y, konvertere dem til PyTorch-tensorer, og omforme dem til 2D-tensorer for å sikre kompatibilitet med PyTorch-operasjoner:


              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. Definere den lineære modellen

Modulen nn.Linear i PyTorch definerer et fullt tilkoblet lag, som utfører y = xWT + b. Dette er en grunnleggende byggestein i nevrale nettverk og kan kombineres med andre lag for mer komplekse arkitekturer.

De viktigste parameterne er:

in_features: antall input-funksjoner (uavhengige variabler);
out_features: antall output-funksjoner (predikerte verdier).

For enkel lineær regresjon, som i vårt tilfelle, predikeres en enkelt output basert på én input. Dermed:

in_features=1: én input-variabel;
out_features=1: én predikert verdi.

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

4. Definere tapfunksjon og optimizer

Vi bruker mean squared error (MSE) som tapfunksjon og stochastic gradient descent (SGD) som optimizer med læringsrate satt til 0.005.

MSE-tapet kan defineres ved å bruke nn.MSELoss-klassen, og SGD ved å bruke den respektive klassen fra torch.optim-modulen.

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. Trening av modellen

Trening innebærer å utføre et forward pass og et backward pass for et spesifisert antall epoker.

Forward pass: dette steget beregner modellens prediksjoner basert på inputdata og beregner tapet ved å sammenligne prediksjonene med de faktiske målverdiene;
Backward pass: dette steget beregner gradienter ved hjelp av backpropagation (basert på tapet) og oppdaterer modellens vekter og bias ved hjelp av en optimaliseringsalgoritme, som i vårt tilfelle er SGD.

Denne prosessen gjentas for det angitte antallet epoker for å minimere tapet og forbedre modellens ytelse.


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

Parameterne til modellen, nemlig vekter og bias, kan nås ved å bruke attributtene .weight og .bias:

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

Merk

optimizer.zero_grad() er viktig fordi det nullstiller gradientene til alle parametere før tilbakepropagering. Uten dette trinnet vil gradientene akkumulere fra tidligere steg, noe som fører til feil oppdateringer av modellens vekter. Dette sikrer at hver bakoverpassering starter med blanke ark.

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 13

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Sveip for å vise menyen