Leer Aanmaak van een Eenvoudig Neuraal Netwerk | Neurale Netwerken in PyTorch

Ons doel is het bouwen van een eenvoudig PyTorch-neuraal netwerk met behulp van de digits dataset, een klassieke dataset binnen 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).

Overzicht van de dataset

De digits dataset bevat afbeeldingen van handgeschreven cijfers die zijn weergegeven als numerieke pixelwaarden. Elke sample bestaat uit 64 kenmerken, overeenkomend met de pixelintensiteiten van een 8×8 grijswaardenafbeelding. De doelvariabele ('target' kolom) geeft de cijferklasse (0-9) aan, wat aangeeft 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 output 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 dienen alle benodigde PyTorch-modules (nn, F) te 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 in een functionele stijl worden gebruikt.

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

We kunnen nu 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 reeds bekend bestaat een MLP uit volledig verbonden lagen (ook wel dense lagen genoemd), waarbij verborgen lagen de invoerkenmerken verwerken en de outputlaag 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) gestuurd, gevolgd door de ReLU-activatiefunctie 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 outputlaag (out) gestuurd, die de ruwe scores (logits) voor de outputklassen 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.

Hierdoor is het resulterende model 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


              12345678910111213141516171819202122232425262728293031323334
            
import torch.nn as nn
import torch.nn.functional as F
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

# Define the model class
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

    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
      
# Define model parameters
input_features = X.shape[1]  # Number of features (pixels)
hidden1 = 32  # Number of neurons in first hidden layer
hidden2 = 16  # Number of neurons in second hidden layer
output_classes = len(digits_df["target"].unique())  # Number of unique digits (0-9)
# Create an instance of the model
model = DigitsClassifier(input_features, hidden1, hidden2, output_classes)
# Display the model structure
print(model)

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 3. Hoofdstuk 1

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Suggested prompts:

Can you explain how to train this model on the digits dataset?

What loss function and optimizer should I use for this classification task?

How do I evaluate the model's performance after training?

Awesome!

Completion rate improved to 5

Veeg om het menu te tonen