Målet er at opbygge et grundlæggende PyTorch-neuralt netværk ved hjælp af digits-datasættet, et klassisk datasæt inden for maskinlæring. Opgaven er at forudsige cifret (målvariabel) baseret på billedet af dets håndskrift, repræsenteret som et sæt pixelværdier (egenskaber).

Datasætoversigt

Digits-datasættet indeholder håndskrevne cifre repræsenteret som numeriske pixelværdier. Hvert eksempel består af 64 egenskaber, svarende til pixelintensiteter fra et 8×8 gråtonebillede. Målvariablen ('target'-kolonnen) repræsenterer cifret (0-9), hvilket angiver hvilket tal billedet svarer til.

Første trin er at læse CSV-filen og udtrække egenskaberne (X) og målvariablen (y), som repræsenterer det output, vi ønsker at forudsige:

import pandas as pd

digits_df = pd.read_csv('https://staging-content-media-cdn.codefinity.com/courses/1dd2b0f6-6ec0-40e6-a570-ed0ac2209666/section_3/digits.csv')
# Extract features and target
X = digits_df.drop(columns=["target"]).values
y = digits_df["target"].values

Definition af modelklassen

Først skal alle nødvendige PyTorch-moduler (nn, F) importeres. nn-modulet bruges til at definere modellag og arkitekturer, mens F-modulet indeholder aktiveringsfunktioner, tabfunktioner og andre værktøjer, der ofte anvendes i en funktionel stil.

import torch.nn as nn
import torch.nn.functional as F

Vi kan nu fortsætte med at definere modelklassen:

class DigitsClassifier(nn.Module):
    ...

Modelarkitektur

Da opgaven er en simpel multiklassifikationsopgave, er et multilagsperceptron (MLP) med 2 skjulte lag tilstrækkeligt.

class DigitsClassifier(nn.Module):
    def __init__(self, input_features, hidden1, hidden2, output_classes):
        super().__init__()
        # Define the layers
        self.fc1 = nn.Linear(input_features, hidden1)  # Input to first hidden layer
        self.fc2 = nn.Linear(hidden1, hidden2)  # First hidden to second hidden layer
        self.out = nn.Linear(hidden2, output_classes)  # Second hidden to output layer

Som du allerede ved, består et MLP af fuldt forbundne lag (også kaldet tætte lag), hvor skjulte lag behandler inputfunktionerne, og outputlaget leverer de endelige klasseforudsigelser. Disse fuldt forbundne lag er repræsenteret som nn.Linear lag i PyTorch.

Fremadrettet propagering

Denne .forward()-metode definerer fremadrettet propagering af data gennem modellen.

def forward(self, x):
    # Pass data through layers with activation functions
    a1 = F.relu(self.fc1(x))  # First hidden layer with ReLU
    a2 = F.relu(self.fc2(a1))  # Second hidden layer with ReLU
    output = self.out(a2)          # Output layer (no activation for raw scores)
    return output

Input-tensoren x sendes først gennem det første fuldt forbundne lag (fc1), efterfulgt af ReLU-aktiveringsfunktionen for at introducere ikke-linearitet. Derefter går den gennem det andet fuldt forbundne lag (fc2), igen efterfulgt af ReLU.

Til sidst passerer de transformerede data gennem outputlaget (out), som producerer rå scorer (logits) for outputklasserne.

Oprettelse af modellen

Da modelklassen nu er defineret, kan vi nu definere modelparametre og instantiere modellen.

Ligesom med antallet af skjulte lag, vælges antallet af neuroner i hvert skjult lag vilkårligt i vores eksempel: 32 og 16 for henholdsvis det første og andet skjulte lag.

Følgelig er den resulterende model struktureret som følger:

• Inputlag: matcher antallet af features i datasættet (64 for dette datasæt);
• Skjulte lag: vilkårligt antal neuroner (32 og 16);
• Outputlag: matcher antallet af klasser (10 cifre).

Komplet implementering