Módulo redes neuronalesParte 2 de 2

Construyendo un MLP

De la neurona a la red multicapa completa

🏗️ Construyendo un MLP

Un Multi-Layer Perceptron (MLP) es simplemente una pila de capas lineales separadas por funciones de activación.

1. La Capa Lineal (Linear Layer)

Implementamos una capa que soporta múltiples neuronas y almacenamiento de resultados para backprop.
capa_densa.py
1import torch
2
3class LinearLayer:
4  def __init__(self, n_inputs, n_neurons):
5      # Escalar pesos para evitar gradientes explosivos
6      self.weights = 0.01 * torch.randn(n_inputs, n_neurons)
7      self.bias = torch.zeros(1, n_neurons)
8      
9  def forward(self, inputs):
10      self.output = torch.matmul(inputs, self.weights) + self.bias
11      return self.output

2. Uniendo todo: Red Neuronal Simple

Usando torch.nn.Module, la clase base de PyTorch para todas las redes.
red_completa.py
1import torch.nn as nn
2
3class SimpleNet(nn.Module):
4  def __init__(self):
5      super().__init__()
6      self.layer1 = nn.Linear(2, 4) # 2 entradas -> 4 ocultas
7      self.relu = nn.ReLU()
8      self.layer2 = nn.Linear(4, 1) # 4 ocultas -> 1 salida
9      self.sigmoid = nn.Sigmoid()
10      
11  def forward(self, x):
12      x = self.layer1(x)
13      x = self.relu(x)
14      x = self.layer2(x)
15      x = self.sigmoid(x)
16      return x
17
18model = SimpleNet()
19input_data = torch.randn(5, 2) # Batch de 5 ejemplos
20output = model(input_data)
21print(output)

Loop de Entrenamiento

El ciclo estándar es:
  1. Forward: Calcular predicción.
  2. Loss: Calcular error.
  3. Backward: Calcular gradientes.
  4. Step: Actualizar pesos.