Lære Oprettelse af et Simpelt Neuralt Netværk

Målet er at opbygge et grundlæggende PyTorch-neuralt netværk ved hjælp af digits dataset, 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 (features).

Datasætoversigt

Digits dataset indeholder håndskrevne cifre repræsenteret som numeriske pixelværdier. Hvert eksempel består af 64 features, 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 features (X) og målvariabel (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

Nu kan vi fortsætte med at definere modelklassen:

class DigitsClassifier(nn.Module):
    ...

Modelarkitektur

Da opgaven er en simpel multiklassifikationsopgave, er et multilags perceptron (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.

Fremadpropagering

Denne .forward() metode definerer fremadpropageringen 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 aktiveringsfunktion 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å score (logits) for outputklasserne.

Oprettelse af modellen

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

Ligesom antallet af skjulte lag, vælges antallet af neuroner i hvert skjult lag vilkårligt i vores eksempel: 32 og 16 for henholdsvis 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


              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)

Var alt klart?

Tak for dine kommentarer!

Sektion 3. Kapitel 1

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

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

Stryg for at vise menuen