Lära Linjär Regression | Mer Avancerade Koncept

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ålvariabel, Y).

1. Ladda och inspektera datamängden

Datamängden är sparad 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

Därefter bör vi 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 huvudsakliga parametrar är:

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

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

in_features=1: en indata variabel;
out_features=1: ett predicerat 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ål-värdena;
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 är SGD i vårt fall.

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

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 3

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

Suggested prompts:

Can you explain how the training loop works in more detail?

What do the trained weight and bias values represent?

How can I use this trained model to make predictions on new data?

Awesome!

Completion rate improved to 5

Svep för att visa menyn