Nosso objetivo é construir uma rede neural básica em PyTorch utilizando o digits dataset, um conjunto de dados clássico em aprendizado de máquina. A tarefa consiste em prever o dígito (alvo) com base na imagem de sua escrita manual, representada por um conjunto de valores de pixels (características).

Visão Geral do Conjunto de Dados

O digits dataset contém imagens de dígitos manuscritos representadas como valores numéricos de pixels. Cada amostra possui 64 características, correspondentes às intensidades dos pixels de uma imagem em tons de cinza 8×8. A variável alvo ('target' column) representa a classe do dígito (0-9), indicando qual número a imagem representa.

O primeiro passo é ler o arquivo CSV e extrair as características (X) e a variável alvo (y), que representa a saída que desejamos prever:

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

Definição da Classe do Modelo

Primeiramente, todos os módulos necessários do PyTorch (nn, F) devem ser importados. O módulo nn é utilizado para definir camadas e arquiteturas do modelo, enquanto o módulo F contém funções de ativação, funções de perda e outras utilidades frequentemente usadas de forma funcional.

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

Agora podemos prosseguir com a definição da classe do modelo:

class DigitsClassifier(nn.Module):
    ...

Arquitetura do Modelo

Como a tarefa é uma classificação multiclasse simples, um perceptron multicamadas (MLP) com 2 camadas ocultas é suficiente.

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

Como já mencionado, um MLP é composto por camadas totalmente conectadas (também chamadas de camadas densas), onde as camadas ocultas processam as características de entrada e a camada de saída fornece as previsões finais das classes. Essas camadas totalmente conectadas são representadas como camadas nn.Linear no PyTorch.

Propagação Direta

O método .forward() define a propagação direta dos dados através do modelo.

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

O tensor de entrada x é primeiramente passado pela primeira camada totalmente conectada (fc1), seguida pela função de ativação ReLU para introduzir não linearidade. Em seguida, passa pela segunda camada totalmente conectada (fc2), novamente seguida por ReLU.

Por fim, os dados transformados passam pela camada de saída (out), que produz os escores brutos (logits) para as classes de saída.

Criação do Modelo

Como a classe do modelo já está definida, agora podemos definir os parâmetros do modelo e instanciar o modelo.

De forma semelhante ao número de camadas ocultas, o número de neurônios em cada camada oculta é escolhido de maneira arbitrária em nosso exemplo: 32 e 16 para a primeira e segunda camadas ocultas, respectivamente.

Consequentemente, o modelo resultante é estruturado da seguinte forma:

• Camada de entrada: corresponde ao número de características do conjunto de dados (64 para este conjunto de dados);
• Camadas ocultas: quantidades arbitrárias de neurônios (32 e 16);
• Camada de saída: corresponde ao número de classes (10 dígitos).

Implementação Completa