Lære Lineær Regresjon

Sveip for å vise menyen

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 enkel 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 tapfunksjonen og optimeringsalgoritmen

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

MSE-tapet kan defineres ved å bruke klassen nn.MSELoss, 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 fremoverpass og et bakoverpass for et spesifisert antall epoker.

Fremoverpass: dette steget beregner modellens prediksjoner basert på inndataene og kalkulerer tapet ved å sammenligne prediksjonene med de faktiske målverdiene;
Bakoverpass: dette steget beregner gradienter ved hjelp av backpropagation (basert på tapet) og oppdaterer modellens vekter og bias ved hjelp av en optimeringsalgoritme, 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 dens vekter og biaser, 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 tilbakestiller gradientene til alle parametere før tilbakepropagering. Uten dette steget ville gradientene akkumulert fra tidligere steg, noe som ville ført til feilaktige 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

Seksjon 1. Kapittel 13