deep-learning · temario
3.1tema 1 de 4

Neural Networks — Architecture & Training

Neuronas, capas, activaciones y entrenamiento con gradientes

Una red neuronal es una pila de transformaciones matemáticas encadenadas. Cada capa recibe un tensor, lo multiplica por una matriz de pesos, le suma un sesgo y aplica una función de activación. El resultado pasa a la siguiente capa, igual que en una línea de ensamblaje donde cada estación transforma el producto antes de entregarlo.

La neurona individual no es más que una suma ponderada seguida de una no-linealidad: y = activation(W·x + b). Sin la activación, apilar capas equivaldría a una sola multiplicación de matrices. La no-linealidad (ReLU, sigmoid, tanh) es lo que da al modelo su capacidad de aprender funciones complejas.

El forward pass es el camino de la entrada hacia la salida: los datos fluyen capa por capa y el modelo produce una predicción. El loss mide el error entre esa predicción y la etiqueta real. Piénsalo como la diferencia entre el precio que cotizaste y el precio real del proyecto.

El backward pass (backpropagation) aplica la regla de la cadena del cálculo diferencial para calcular cuánto contribuye cada peso al error total. Gradient descent usa esos gradientes para ajustar los pesos en la dirección que reduce el loss, con un paso controlado por el learning rate.

El overfitting ocurre cuando la red memoriza el conjunto de entrenamiento en lugar de generalizar. Las técnicas más comunes para controlarlo son dropout (apaga neuronas aleatoriamente durante el entrenamiento), weight decay (penaliza pesos grandes en el loss) y early stopping (detiene el entrenamiento cuando el error de validación deja de mejorar).

Elegir la función de loss correcta es tan crítico como la arquitectura. CrossEntropyLoss para clasificación multi-clase, BCEWithLogitsLoss para clasificación binaria, MSELoss para regresión. Mezclar loss y activación de salida incorrectamente es uno de los bugs más comunes en deep learning.

structure.txt
FORWARD PASS
  input  →  [Linear → Activation] × N layers  →  output logits
  loss   =  criterion(logits, targets)

BACKWARD PASS
  loss.backward()          # compute gradients
  optimizer.step()         # update weights
  optimizer.zero_grad()    # reset gradients for next iteration

NEURON
  y = activation(W @ x + b)

COMMON ACTIVATIONS
  hidden layers  →  ReLU / GELU / LeakyReLU
  binary output  →  Sigmoid
  multi-class    →  Softmax (or via CrossEntropyLoss)
  regression     →  None (linear)

REGULARIZATION
  nn.Dropout(p=0.3)         # zero out neurons randomly
  weight_decay=1e-4         # L2 penalty in optimizer

Debugging lab

Detecta y corrige el error en el código.

0/5 tests passing0%
  1. 3.1.5.1

    output = torch.sigmoid(self.fc(x)) # binary classification

  2. 3.1.5.2

    criterion = nn.CrossEntropyLoss() output = torch.softmax(self.fc(x), dim=1) loss = criterion(output, labels)

  3. 3.1.5.3

    for epoch in range(epochs): loss.backward() optimizer.step()

  4. 3.1.5.4

    # regression task output = torch.sigmoid(self.fc(x)) loss = nn.MSELoss()(output, targets)

  5. 3.1.5.5

    self.dropout = nn.Dropout(p=0.5) # forward: x = self.dropout(x) x = torch.relu(self.fc(x))