Ons doel is om een eenvoudig PyTorch-neuraal netwerk te bouwen met behulp van de digits dataset, een klassieke dataset in machine learning. De taak is het voorspellen van het cijfer (doelvariabele) op basis van de afbeelding van het handschrift, weergegeven als een reeks pixelwaarden (kenmerken).

Datasetoverzicht

De digits dataset bevat afbeeldingen van handgeschreven cijfers die worden weergegeven als numerieke pixelwaarden. Elke instantie bestaat uit 64 kenmerken, die overeenkomen met de pixelintensiteiten van een 8×8 grijswaardenafbeelding. De doelvariabele ('target' kolom) geeft de cijferklasse (0-9) aan, oftewel welk getal de afbeelding voorstelt.

De eerste stap is het inlezen van het CSV-bestand en het extraheren van de kenmerken (X) en de doelvariabele (y), die de uitkomst vertegenwoordigt die we willen voorspellen:

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

Definitie van de Modelklasse

Allereerst moeten alle benodigde PyTorch-modules (nn, F) worden geïmporteerd. De nn-module wordt gebruikt voor het definiëren van modellagen en -architecturen, terwijl de F-module activatiefuncties, verliesfuncties en andere hulpmiddelen bevat die vaak op een functionele manier worden gebruikt.

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

Nu kunnen we doorgaan met het definiëren van de modelklasse:

class DigitsClassifier(nn.Module):
    ...

Modelarchitectuur

Aangezien de taak een eenvoudige multiclass-classificatie betreft, is een multilayer perceptron (MLP) met 2 verborgen lagen voldoende.

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

Zoals bekend bestaat een MLP uit volledig verbonden lagen (ook wel dense lagen genoemd), waarbij verborgen lagen de invoerkenmerken verwerken en de uitvoerlaag de uiteindelijke klassevoorspellingen levert. Deze volledig verbonden lagen worden in PyTorch weergegeven als nn.Linear-lagen.

Voorwaartse propagatie

Deze .forward()-methode definieert de voorwaartse propagatie van data door het model.

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

De invoertensor x wordt eerst door de eerste volledig verbonden laag (fc1) geleid, gevolgd door de ReLU-activeringsfunctie om non-lineariteit toe te voegen. Vervolgens gaat het door de tweede volledig verbonden laag (fc2), opnieuw gevolgd door ReLU.

Ten slotte wordt de getransformeerde data door de uitvoerlaag (out) geleid, die de ruwe scores (logits) voor de uitvoerklassen produceert.

Het model aanmaken

Nu de modelklasse is gedefinieerd, kunnen we modelparameters definiëren en het model instantiëren.

Net als bij het aantal verborgen lagen wordt het aantal neuronen in elke verborgen laag in ons voorbeeld willekeurig gekozen: 32 en 16 voor respectievelijk de eerste en tweede verborgen laag.

Het resulterende model is daarom als volgt opgebouwd:

• Invoerlaag: komt overeen met het aantal kenmerken in de dataset (64 voor deze dataset);
• Verborgen lagen: willekeurige aantallen neuronen (32 en 16);
• Uitvoerlaag: komt overeen met het aantal klassen (10 cijfers).

Volledige implementatie