Målet vårt er å bygge et grunnleggende PyTorch-nevralt nettverk ved å bruke digits-datasettet, et klassisk datasett innen maskinlæring. Oppgaven er å forutsi sifferet (målvariabel) basert på bildet av håndskriften, representert som et sett med pikselverdier (egenskaper).

Oversikt over datasettet

Digits-datasettet inneholder bilder av håndskrevne sifre representert som numeriske pikselverdier. Hver prøve består av 64 egenskaper, som tilsvarer pikselintensiteter fra et 8×8 gråtonebilde. Målvariabelen ('target'-kolonnen) representerer sifferklassen (0-9), som angir hvilket tall bildet tilsvarer.

Første steg er å lese CSV-filen og hente ut egenskapene (X) og målvariabelen (y), som representerer utdataen vi ønsker å forutsi:

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

Definere modellklassen

Først må alle nødvendige PyTorch-moduler (nn, F) importeres. nn-modulen brukes til å definere modellag og arkitekturer, mens F-modulen inneholder aktiveringsfunksjoner, tapsfunksjoner og andre verktøy som ofte brukes i en funksjonell stil.

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

Vi kan nå fortsette med å definere modellklassen:

class DigitsClassifier(nn.Module):
    ...

Modellarkitektur

Siden oppgaven er en enkel multiklasseklassifisering, er et multilags perseptron (MLP) med 2 skjulte lag tilstrekkelig.

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 vet, består et MLP av fullt tilkoblede lag (også kalt tette lag), der skjulte lag prosesserer inndatafunksjonene, og utgangslaget gir de endelige klasseprediksjonene. Disse fullt tilkoblede lagene er representert som nn.Linear-lag i PyTorch.

Fremoverpropagering

Denne .forward()-metoden definerer fremoverpropageringen av data gjennom 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

Inndatatensoren x sendes først gjennom det første fullt tilkoblede laget (fc1), etterfulgt av ReLU-aktiveringsfunksjonen for å introdusere ikke-linearitet. Deretter går den gjennom det andre fullt tilkoblede laget (fc2), igjen etterfulgt av ReLU.

Til slutt passerer de transformerede dataene gjennom utgangslaget (out), som produserer rå score (logitter) for utgangsklassene.

Opprettelse av modellen

Siden modellklassen nå er definert, kan vi nå definere modellparametere og instansiere modellen.

På samme måte som antall skjulte lag, velges antall nevroner i hvert skjult lag noe vilkårlig i vårt eksempel: 32 og 16 for henholdsvis første og andre skjulte lag.

Følgelig er den resulterende modellen strukturert som følger:

• Inndatalag: tilsvarer antall funksjoner i datasettet (64 for dette datasettet);
• Skjulte lag: vilkårlig antall nevroner (32 og 16);
• Utgangslag: tilsvarer antall klasser (10 sifre).

Fullstendig implementering