Leer Lineaire Regressie | Meer Geavanceerde Concepten

We gebruiken een echte dataset om lineaire regressie in PyTorch te implementeren. De dataset bevat twee kolommen:

'Number of Appliances': het aantal apparaten in een huishouden (invoerkenmerk, X);
'Electricity Bill': het bijbehorende bedrag van de elektriciteitsrekening (doeluitvoer, Y).

1. Laden en Inspecteren van de Dataset

De dataset is opgeslagen in een CSV-bestand. We laden deze met pandas en inspecteren de eerste paar rijen:


              12345
            
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')
# Display the first five rows
print(bills_df.head())

2. De gegevens voorbereiden voor PyTorch

Vervolgens moeten de inputkolom X en de doeldatkolom Y worden geëxtraheerd, omgezet naar PyTorch-tensors en omgevormd tot 2D-tensors om compatibiliteit met PyTorch-operaties te garanderen:


              12345678910
            
import torch
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)
# Print the shapes of X and Y
print(f"Shape of X: {X.shape}")
print(f"Shape of Y: {Y.shape}")

3. Het lineaire model definiëren

De module nn.Linear in PyTorch definieert een volledig verbonden laag die y = xWT + b uitvoert. Dit is een fundamenteel bouwblok in neurale netwerken en kan worden gecombineerd met andere lagen voor complexere architecturen.

De belangrijkste parameters zijn als volgt:

in_features: aantal invoerkenmerken (onafhankelijke variabelen);
out_features: aantal uitvoerkenmerken (voorspelde waarden).

Voor eenvoudige lineaire regressie, zoals in ons geval, wordt één enkele output voorspeld op basis van één input. Dus:

in_features=1: één invoervariabele;
out_features=1: één voorspelde waarde.

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

4. Het definiëren van de verliesfunctie en optimizer

We gebruiken mean squared error (MSE) als de verliesfunctie en stochastic gradient descent (SGD) als de optimizer met een learning rate van 0.005.

De MSE-verliesfunctie kan worden gedefinieerd met de nn.MSELoss klasse, en SGD met de respectievelijke klasse uit de torch.optim module.

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. Het trainen van het model

Het trainen bestaat uit het uitvoeren van een forward pass en een backward pass gedurende een opgegeven aantal epochs.

Forward pass: deze stap berekent de voorspellingen van het model op basis van de invoergegevens en bepaalt het verlies door de voorspellingen te vergelijken met de werkelijke doelwaarden;
Backward pass: deze stap berekent de gradiënten met behulp van backpropagation (gebaseerd op het verlies) en werkt de gewichten en biases van het model bij met behulp van een optimalisatie-algoritme, in dit geval SGD.

Dit proces wordt herhaald voor het opgegeven aantal epochs om het verlies te minimaliseren en de prestaties van het model te verbeteren.


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

De parameters van het model, namelijk de gewichten en biases, zijn toegankelijk via de attributen .weight en .bias:

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

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 2. Hoofdstuk 3

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Awesome!

Completion rate improved to 5

Veeg om het menu te tonen