Oppiskele Yksinkertaisen Neuroverkon Luominen

Tavoitteenamme on rakentaa perus PyTorch-neuroverkko käyttäen digits dataset -aineistoa, joka on klassinen koneoppimisen aineisto. Tehtävänä on ennustaa numero (kohde) käsinkirjoitetun numeron kuvan perusteella, joka on esitetty pikseliarvojen (piirteiden) joukkona.

Aineiston yleiskatsaus

Digits dataset sisältää käsinkirjoitettujen numeroiden kuvia, jotka on esitetty numeerisina pikseliarvoina. Jokainen havainto koostuu 64 piirteestä, jotka vastaavat pikselin voimakkuuksia 8×8 harmaasävykuvasta. Kohdemuuttuja ('target'-sarake) edustaa numeroluokkaa (0-9), eli kertoo, mikä numero kuvassa on.

Ensimmäinen vaihe on lukea CSV-tiedosto ja erottaa piirteet (X) sekä kohdemuuttuja (y), joka on se arvo, jota pyritään ennustamaan:

import pandas as pd

digits_df = pd.read_csv('https://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

Malliluokan määrittely

Aluksi tulee tuoda kaikki tarvittavat PyTorch-moduulit (nn, F). nn-moduulia käytetään mallin kerrosten ja arkkitehtuurien määrittelyyn, kun taas F-moduuli sisältää aktivointifunktioita, tappiotoimintoja ja muita usein funktionaalisessa tyylissä käytettyjä apuvälineitä.

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

Nyt voidaan siirtyä malliluokan määrittelyyn:

class DigitsClassifier(nn.Module):
    ...

Mallin arkkitehtuuri

Koska kyseessä on yksinkertainen moniluokkainen luokittelutehtävä, riittää monikerroksinen perceptroni (MLP), jossa on 2 piilokerrosta.

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

Kuten jo tiedät, MLP koostuu täysin yhdistetyistä kerroksista (myös tiheät kerrokset), joissa piilokerrokset käsittelevät syöteominaisuuksia ja ulostulokerros tuottaa lopulliset luokkaprediktiot. Nämä täysin yhdistetyt kerrokset toteutetaan PyTorchissa nn.Linear -kerroksina.

Eteenpäin suuntautuva laskenta

Tämä .forward()-metodi määrittelee eteenpäin suuntautuvan laskennan datan kululle mallissa.

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

Syötetensori x kulkee ensin ensimmäisen täysin yhdistetyn kerroksen (fc1) läpi, jonka jälkeen käytetään ReLU-aktivointifunktiota tuomaan epälineaarisuutta. Tämän jälkeen data kulkee toisen täysin yhdistetyn kerroksen (fc2) läpi, jälleen ReLU:n kanssa.

Lopuksi muunnettu data kulkee ulostulokerroksen (out) läpi, joka tuottaa raakatulokset (logitit) ulostuloluokille.

Mallin luominen

Koska malliluokka on nyt määritelty, voidaan määrittää mallin parametrit ja luoda mallin ilmentymä.

Samoin kuin piilotettujen kerrosten lukumäärä, myös neuronien määrä jokaisessa piilotetussa kerroksessa valitaan tässä esimerkissä mielivaltaisesti: 32 ja 16 ensimmäiselle ja toiselle piilotetulle kerrokselle.

Tämän seurauksena syntyvä malli on rakenteeltaan seuraava:

Syötekerros: vastaa aineiston ominaisuuksien määrää (64 tässä aineistossa);
Piilotetut kerrokset: mielivaltaiset neuronimäärät (32 ja 16);
Ulostulokerros: vastaa luokkien määrää (10 numeroa).

Koko toteutus


              12345678910111213141516171819202122232425262728293031323334
            
import torch.nn as nn
import torch.nn.functional as F
import pandas as pd

digits_df = pd.read_csv('https://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)

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 3. Luku 1

Kysy tekoälyä

Kysy mitä tahansa tai kokeile jotakin ehdotetuista kysymyksistä aloittaaksesi keskustelumme

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

Pyyhkäise näyttääksesi valikon