En el Módulo 3 armamos una red completa, pero con un problema grande: sus pesos son aleatorios, así que da respuestas al azar. Este módulo responde la pregunta que lo cambia todo: ¿qué significa exactamente que una red “aprenda”? La respuesta tiene dos partes — una forma de medir qué tan mal lo hace, y una forma de corregirse. Con eso cerramos el bloque básico y dejamos todo listo para backpropagation.

La tesis del módulo

Aprender es minimizar el error. Primero necesitas un número que mida qué tan mal lo hace la red — la función de pérdida. Después, un método para bajar ese número ajustando los pesos poquito a poquito en la dirección correcta — el descenso de gradiente. Todo el entrenamiento de toda red neuronal es esta danza repetida miles de veces.

La función de pérdida: medir el error

La función de pérdida (loss) es un número que mide qué tan mal lo hace la red: compara su predicción con la respuesta correcta y devuelve cuánto se equivocó. Pérdida alta = predicciones malas; pérdida baja = predicciones buenas. Toda la meta del entrenamiento es hacer ese número lo más chico posible.

Cuál función usas depende de la tarea:

Regresión (predecir un número: un precio, una temperatura) → MSE (Mean Squared Error, “error cuadrático medio”). Toma la diferencia entre lo predicho y lo real, la eleva al cuadrado (para que los errores no se cancelen y para castigar más los grandes), y promedia. MSE = promedio( (predicho − real)² ).
Clasificación (elegir una categoría: gato/perro, spam/no-spam) → cross-entropy (entropía cruzada). Mide qué tan lejos está la probabilidad que dio la red de la respuesta correcta. Si el modelo dice “90% gato” y era gato, la pérdida es baja; si dice “5% gato” y era gato, la pérdida se dispara.

	MSE	Cross-entropy
Para qué tarea	Regresión (números)	Clasificación (categorías)
Qué compara	Número predicho vs real	Probabilidad predicha vs clase real
Qué castiga	La distancia al valor real	La confianza en la respuesta equivocada
Salida típica de la red	1 neurona, sin activación	Softmax (probabilidades)
Ejemplo	Predecir el precio de una casa	¿Es gato, perro o pájaro?

El gradiente: la pendiente que apunta hacia arriba

Con la pérdida ya tenemos el número a minimizar. ¿Cómo lo bajamos? Con el gradiente.

El gradiente es, en simple, la pendiente de la función de pérdida respecto a cada peso: te dice cuánto y en qué dirección cambia la pérdida si mueves ese peso un poquito. Si el gradiente de un peso es positivo, subir ese peso sube la pérdida (malo); si es negativo, subir el peso la baja. El gradiente siempre apunta hacia donde la pérdida crece más rápido.

¿Y qué queremos? Bajarla. Entonces nos movemos en dirección contraria al gradiente. De ahí el nombre: descenso de gradiente.

Descenso de gradiente: bajar la montaña con neblina

La analogía clásica: estás en una montaña, con neblina densa, y quieres llegar al valle (la pérdida mínima). No ves el paisaje completo, pero sí puedes sentir con los pies hacia dónde baja el terreno justo donde estás parado. Esa sensación local es el gradiente. La estrategia:

Siente la pendiente bajo tus pies (calcula el gradiente).
Da un paso hacia abajo (ajusta los pesos en dirección contraria al gradiente).
Repite desde la nueva posición.

Paso a paso, sin ver el mapa completo, terminas bajando al valle. Eso es gradient descent (“descenso de gradiente”): ajustar los pesos, una y otra vez, en la dirección que baja la pérdida.

El tamaño de cada paso lo controla el learning rate (tasa de aprendizaje): pasos grandes bajan rápido pero pueden pasarse de largo y rebotar; pasos chicos son seguros pero lentos. Es una perilla clave que ajustaremos con cuidado en el módulo 6.

   pérdida
     ▲
     │●   ← pesos iniciales (aleatorios, error alto)
     │ ╲
     │  ╲ ●   paso 1
     │   ╲ ╲
     │    ╲ ● paso 2
     │     ╲ ╲
     │      ╲ ● paso 3
     │       ╲╲
     │        ●●___ valle: pérdida mínima
     └──────────────────────────────►
              valor de un peso

   cada paso baja un poco la pérdida,
   en dirección contraria al gradiente

Un paso de descenso de gradiente en código

Este es el corazón de todo el entrenamiento, con numpy y un ejemplo mínimo (predecir un número con un solo peso y bias):

import numpy as np

# datos: queremos que la red aprenda y = 2*x
x = np.array([1.0, 2.0, 3.0, 4.0])
y_real = np.array([2.0, 4.0, 6.0, 8.0])

w, b = 0.0, 0.0        # pesos iniciales (mal: predicen todo 0)
learning_rate = 0.01

for paso in range(1000):
    y_pred = w * x + b                     # forward pass
    error = y_pred - y_real
    loss = np.mean(error ** 2)             # MSE: qué tan mal lo hace

    # gradientes: pendiente de la pérdida respecto a w y b
    grad_w = np.mean(2 * error * x)
    grad_b = np.mean(2 * error)

    # el paso: moverse EN CONTRA del gradiente
    w -= learning_rate * grad_w
    b -= learning_rate * grad_b

print(f"w={w:.2f}, b={b:.2f}, loss={loss:.4f}")  # w se acerca a 2, b a 0

Y el mismo ciclo en PyTorch, que calcula los gradientes solo con loss.backward() (el motor que hace eso por dentro es backpropagation, el módulo 5):

import torch

x = torch.tensor([1.0, 2.0, 3.0, 4.0])
y_real = torch.tensor([2.0, 4.0, 6.0, 8.0])

w = torch.tensor(0.0, requires_grad=True)   # PyTorch rastrea sus gradientes
b = torch.tensor(0.0, requires_grad=True)
learning_rate = 0.01

for paso in range(1000):
    y_pred = w * x + b                       # forward pass
    loss = ((y_pred - y_real) ** 2).mean()   # MSE

    loss.backward()                          # calcula grad_w y grad_b solo
    with torch.no_grad():
        w -= learning_rate * w.grad          # el paso de descenso
        b -= learning_rate * b.grad
        w.grad.zero_()                       # limpiar para el próximo paso
        b.grad.zero_()

print(f"w={w.item():.2f}, b={b.item():.2f}")  # -> cerca de w=2, b=0

Ojo: en PyTorch hay que limpiar los gradientes (.zero_() o optimizer.zero_grad()) en cada paso. Si no, se van acumulando de una iteración a otra y el entrenamiento se descompone. Es el error silencioso más común de quien parte.

Errores comunes

Elegir la pérdida equivocada para la tarea. MSE para clasificar o cross-entropy para regresión hace que la red aprenda mal o no aprenda. Regresión → MSE; clasificación → cross-entropy.
Learning rate demasiado alto. Los pasos son tan grandes que la pérdida rebota o explota (sale NaN) en vez de bajar. Si el entrenamiento diverge, lo primero que se baja es el learning rate.
Learning rate demasiado bajo. No diverge, pero avanza tan lento que parece que no aprende. Es el otro extremo.
Olvidar limpiar los gradientes en PyTorch. Se acumulan y arruinan el paso. Es tan común que conviene revisarlo primero cuando algo no entrena.
Confundir la pérdida con la métrica final. La pérdida es lo que la red minimiza; el “accuracy” o el error que le importa al usuario puede ser otro número. Se optimiza uno y se reporta el otro.

Cierre del bloque básico

Con esto cierra el bloque básico del Curso de Redes Neuronales. Ya tienes las cuatro piezas fundacionales: la neurona (M1), la no-linealidad que la hace potente (M2), la red que se arma apilándolas (M3) y el aprendizaje como minimizar una pérdida bajando el gradiente (M4). Todo el deep learning — CNNs, Transformers, LLMs — se apoya sobre estos cuatro ladrillos.

La frase para llevarse

“Aprender es bajar una montaña con neblina: la pérdida te dice qué tan alto estás, el gradiente hacia dónde baja el terreno, y cada paso te acerca un poco más al valle.”

Qué viene

Módulo 5: backpropagation, el motor. En este módulo usamos loss.backward() como una caja mágica que calcula los gradientes. El próximo la abre: backpropagation es el algoritmo que, con la regla de la cadena, reparte el error hacia atrás por toda la red y calcula cuánto tiene que moverse cada peso. Es el corazón de que las redes profundas puedan entrenarse.

Redes Neuronales — Módulo 4: cómo aprende una red I — función de pérdida y descenso de gradiente