Lineare Regression

Wir werden ein reales Datenset verwenden, um lineare Regression in PyTorch zu implementieren. Das Datenset enthält zwei Spalten:

'Number of Appliances': die Anzahl der Geräte in einem Haushalt (Eingabefunktion, X);
'Electricity Bill': der entsprechende Stromrechnungsbetrag (Zielausgabe, Y).

1. Laden und Inspizieren des Datensets

Das Datenset ist in einer CSV-Datei gespeichert. Wir laden es mit pandas und inspizieren die ersten paar 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 wir die Eingabe-X- und Ziel-Y-Spalten extrahieren, sie in PyTorch-Tensoren umwandeln und in 2D-Tensoren umformen, 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 wie folgt:

in_features: Anzahl der Eingabefeatures (unabhängige Variablen);
out_features: Anzahl der Ausgabefeatures (vorhergesagte Werte).

Für einfache lineare Regression, wie in unserem Fall, sagen wir einen einzelnen Output basierend auf einer Eingabe voraus. Daher:

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

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 nn.MSELoss-Klasse definiert werden, und SGD mit der entsprechenden Klasse aus dem torch.optim-Modul.

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: Dieser Schritt berechnet die Vorhersagen des Modells basierend auf den Eingabedaten und berechnet den Verlust, indem die Vorhersagen mit den tatsächlichen Zielwerten verglichen werden;
Backward Pass: Dieser Schritt berechnet die Gradienten mittels Backpropagation (basierend auf dem Verlust) und aktualisiert die Gewichte und Biases des Modells mit einem Optimierungsalgorithmus, der in unserem Fall SGD ist.

Dieser Prozess wird für die festgelegte Anzahl von Epochen wiederholt, um den Verlust zu minimieren und die Leistung des Modells 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()}")

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 3