Lernen Lineare Regression | Fortgeschrittenere Konzepte

Wir verwenden einen realen Datensatz, um lineare Regression in PyTorch zu implementieren. Der Datensatz enthält zwei Spalten:

'Number of Appliances': Anzahl der Geräte in einem Haushalt (Eingabemerkmal, X);
'Electricity Bill': zugehöriger Betrag der Stromrechnung (Zielwert, Y).

1. Laden und Überprüfen des Datensatzes

Der Datensatz ist in einer CSV-Datei gespeichert. Wir laden ihn mit pandas und überprüfen die ersten Zeilen:


              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. Vorbereitung der Daten für PyTorch

Als Nächstes sollten die Eingabe-X- und Ziel-Y-Spalten extrahiert, in PyTorch-Tensoren umgewandelt und in 2D-Tensoren umgeformt werden, um die Kompatibilität mit den Operationen von PyTorch sicherzustellen:


              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. Definition des linearen Modells

Das nn.Linear-Modul in PyTorch definiert eine vollständig verbundene Schicht, die y = xWT + b ausführt. Es ist ein grundlegender Baustein in neuronalen Netzwerken und kann mit anderen Schichten für komplexere Architekturen kombiniert werden.

Die wichtigsten Parameter sind:

in_features: Anzahl der Eingabemerkmale (unabhängige Variablen);
out_features: Anzahl der Ausgabemerkmale (vorhergesagte Werte).

Für eine einfache lineare Regression, wie in unserem Fall, wird ein einzelner Output basierend auf einer Eingabe vorhergesagt. Daher gilt:

in_features=1: eine Eingabevariable;
out_features=1: ein vorhergesagter Wert.

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

4. Definition der Verlustfunktion und des Optimierers

Wir verwenden Mean Squared Error (MSE) als Verlustfunktion und Stochastic Gradient Descent (SGD) als Optimierer mit einer Lernrate von 0.005.

Der MSE-Verlust kann mit der Klasse nn.MSELoss definiert werden, und SGD mit der entsprechenden Klasse aus dem Modul 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. Training des Modells

Das Training umfasst das Durchführen eines Forward Pass und eines Backward Pass für eine festgelegte Anzahl von Epochen.

Forward Pass: In diesem Schritt berechnet das Modell Vorhersagen basierend auf den Eingabedaten und ermittelt den Verlust, indem die Vorhersagen mit den tatsächlichen Zielwerten verglichen werden;
Backward Pass: In diesem Schritt werden die Gradienten mithilfe von Backpropagation (basierend auf dem Verlust) berechnet und die Gewichte und Biases des Modells mit einem Optimierungsalgorithmus, in unserem Fall SGD, aktualisiert.

Dieser Prozess wird für die festgelegte Anzahl von Epochen wiederholt, um den Verlust zu minimieren und die Modellleistung zu verbessern.


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

Die Parameter des Modells, nämlich seine Gewichte und Biases, können über die Attribute .weight und .bias abgerufen werden:

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

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 3

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Awesome!

Completion rate improved to 5

Swipe um das Menü anzuzeigen