Nuestro objetivo es construir una red neuronal básica en PyTorch utilizando el conjunto de datos digits, un conjunto clásico en el aprendizaje automático. La tarea consiste en predecir el dígito (objetivo) a partir de la imagen de su escritura a mano, representada como un conjunto de valores de píxeles (características).

Descripción del conjunto de datos

El conjunto de datos digits contiene imágenes de dígitos escritos a mano representadas como valores numéricos de píxeles. Cada muestra consta de 64 características, que corresponden a las intensidades de los píxeles de una imagen en escala de grises de 8×8. La variable objetivo (columna 'target') representa la clase del dígito (0-9), indicando a qué número corresponde la imagen.

El primer paso es leer el archivo CSV y extraer las características (X) y la variable objetivo (y), que representa la salida que se desea predecir:

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

Definición de la clase del modelo

Primero, se deben importar todos los módulos necesarios de PyTorch (nn, F). El módulo nn se utiliza para definir capas y arquitecturas del modelo, mientras que el módulo F contiene funciones de activación, funciones de pérdida y otras utilidades que suelen emplearse en un estilo funcional.

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

Ahora se puede proceder a definir la clase del modelo:

class DigitsClassifier(nn.Module):
    ...

Arquitectura del Modelo

Dado que la tarea es una clasificación multiclase simple, un perceptrón multicapa (MLP) con 2 capas ocultas es 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 ya se sabe, un MLP consta de capas totalmente conectadas (también llamadas capas densas), donde las capas ocultas procesan las características de entrada y la capa de salida proporciona las predicciones finales de clase. Estas capas totalmente conectadas se representan como capas nn.Linear en PyTorch.

Propagación Hacia Adelante

El método .forward() define la propagación hacia adelante de los datos a través del 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

El tensor de entrada x se pasa primero por la primera capa totalmente conectada (fc1), seguida de la función de activación ReLU para introducir no linealidad. Luego pasa por la segunda capa totalmente conectada (fc2), nuevamente seguida de ReLU.

Finalmente, los datos transformados pasan por la capa de salida (out), que produce los valores brutos (logits) para las clases de salida.

Creación del Modelo

Ahora que la clase del modelo está definida, podemos definir los parámetros del modelo e instanciar el modelo.

De manera similar al número de capas ocultas, el número de neuronas en cada capa oculta se elige de forma arbitraria en nuestro ejemplo: 32 y 16 para la primera y segunda capa oculta, respectivamente.

En consecuencia, el modelo resultante se estructura de la siguiente manera:

• Capa de entrada: coincide con el número de características en el conjunto de datos (64 para este conjunto de datos);
• Capas ocultas: cantidades arbitrarias de neuronas (32 y 16);
• Capa de salida: coincide con el número de clases (10 dígitos).

Implementación Completa