Lära Skapande av Ett Enkelt Neuralt Nätverk

Vårt mål är att bygga ett grundläggande PyTorch-neuralt nätverk med hjälp av digits dataset, en klassisk datamängd inom maskininlärning. Uppgiften är att förutsäga siffran (målvariabel) baserat på bilden av dess handskrift, representerad som en uppsättning pixelvärden (egenskaper).

Datamängdsöversikt

Digits dataset innehåller bilder av handskrivna siffror representerade som numeriska pixelvärden. Varje prov består av 64 egenskaper, vilka motsvarar pixelintensiteter från en 8×8 gråskalebild. Målvariabeln ('target'-kolumnen) representerar sifferklassen (0-9), vilket anger vilket tal bilden motsvarar.

Första steget är att läsa in CSV-filen och extrahera egenskaperna (X) samt målvariabeln (y), vilket är det utdata vi vill förutsäga:

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 av modellklass

Först ska alla nödvändiga PyTorch-moduler (nn, F) importeras. Modulen nn används för att definiera modellager och arkitekturer, medan modulen F innehåller aktiveringsfunktioner, förlustfunktioner och andra verktyg som ofta används i funktionell stil.

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

Nu kan vi gå vidare med att definiera modellklassen:

class DigitsClassifier(nn.Module):
    ...

Modellarkitektur

Eftersom uppgiften är en enkel multiklassklassificering, är en multilagerperceptron (MLP) med 2 dolda lager tillräcklig.

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 redan känt består en MLP av fullt anslutna lager (även kallade täta lager), där dolda lager bearbetar indatafunktionerna och utgångslagret ger de slutliga klassprediktionerna. Dessa fullt anslutna lager representeras som nn.Linear-lager i PyTorch.

Framåtriktad propagiering

Denna .forward()-metod definierar framåtriktad propagiering av data genom 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

Indatatensorn x skickas först genom det första fullt anslutna lagret (fc1), följt av ReLU-aktiveringsfunktionen för att introducera icke-linjäritet. Därefter går den genom det andra fullt anslutna lagret (fc2), återigen följt av ReLU.

Slutligen passerar den transformerade datan genom utgångslagret (out), vilket producerar råa poäng (logits) för utgångsklasserna.

Skapa modellen

Eftersom modellklassen nu är definierad kan vi nu definiera modellparametrar och instansiera modellen.

På samma sätt som antalet dolda lager väljs antalet neuroner i varje dolt lager något godtyckligt i vårt exempel: 32 och 16 för det första respektive andra dolda lagret.

Följaktligen är den resulterande modellen strukturerad enligt följande:

Ingångslager: motsvarar antalet funktioner i datasettet (64 för detta dataset);
Dolda lager: godtyckligt antal neuroner (32 och 16);
Utgångslager: motsvarar antalet klasser (10 siffror).

Komplett implementation


              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 allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 1

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

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 prepare the data for input into the PyTorch model?

Svep för att visa menyn

Datamängdsöversikt

Första steget är att läsa in CSV-filen och extrahera egenskaperna (X) samt målvariabeln (y), vilket är det utdata vi vill förutsäga:

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 av modellklass

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

Nu kan vi gå vidare med att definiera modellklassen:

class DigitsClassifier(nn.Module):
    ...

Modellarkitektur

Eftersom uppgiften är en enkel multiklassklassificering, är en multilagerperceptron (MLP) med 2 dolda lager tillräcklig.

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

Framåtriktad propagiering

Denna .forward()-metod definierar framåtriktad propagiering av data genom 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

Slutligen passerar den transformerade datan genom utgångslagret (out), vilket producerar råa poäng (logits) för utgångsklasserna.

Skapa modellen

Eftersom modellklassen nu är definierad kan vi nu definiera modellparametrar och instansiera modellen.

På samma sätt som antalet dolda lager väljs antalet neuroner i varje dolt lager något godtyckligt i vårt exempel: 32 och 16 för det första respektive andra dolda lagret.

Följaktligen är den resulterande modellen strukturerad enligt följande:

Ingångslager: motsvarar antalet funktioner i datasettet (64 för detta dataset);
Dolda lager: godtyckligt antal neuroner (32 och 16);
Utgångslager: motsvarar antalet klasser (10 siffror).

Komplett implementation


              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 allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 1

Skapande av Ett Enkelt Neuralt Nätverk

Datamängdsöversikt

Definition av modellklass

Modellarkitektur

Framåtriktad propagiering

Skapa modellen

Komplett implementation

Awesome!

Skapande av Ett Enkelt Neuralt Nätverk

Datamängdsöversikt

Definition av modellklass

Modellarkitektur

Framåtriktad propagiering

Skapa modellen

Komplett implementation