CodeUtility
Haz que programar sea más fácil.
Conceptos de IA en Python

Descenso de gradiente y retropropagación en Python

Entrenar significa ajustar los pesos para reducir la pérdida. El gradiente indica la dirección en la que crece la pérdida, así que el descenso de gradiente da pasos pequeños en la dirección contraria. La retropropagación usa la regla de la cadena para calcular ese gradiente para cada peso.

El concepto en palabras sencillas

Entrenar significa ajustar los pesos para reducir la pérdida. El gradiente indica la dirección en la que crece la pérdida, así que el descenso de gradiente da pasos pequeños en la dirección contraria. La retropropagación usa la regla de la cadena para calcular ese gradiente para cada peso.

Entrena una neurona con descenso de gradiente: usa la regla de la cadena para saber cómo afecta cada peso a la pérdida y baja la pendiente.

Ideas clave

  • El gradiente es la pendiente de la pérdida respecto a cada peso.
  • La tasa de aprendizaje fija el tamaño del paso: demasiado grande se pasa, demasiado pequeña es lenta.
  • La retropropagación aplica la regla de la cadena desde la salida hasta la primera capa.
  • Una época es una pasada completa por todos los datos de entrenamiento.

¿Cuándo se utiliza?

  • Entender qué pasa dentro de las redes neuronales y las bibliotecas de IA.
  • Aprender la idea antes de implementarla en los retos correspondientes.
  • Prepararte para cursos de aprendizaje automático, entrevistas y proyectos.

Pruébalo en acción

Pulsa Reproducir para entrenar. La recta se acerca a los puntos mientras el camino naranja baja por el paisaje de pérdida hasta su punto más bajo.

Código de ejemplo

Ejecutar código →
main.py
# Train one neuron y = w * x + b to fit points on the line y = 2x + 1.
data = [(0, 1), (1, 3), (2, 5), (3, 7)]
w, b = 0.0, 0.0
learning_rate = 0.05

for epoch in range(1, 201):
    grad_w = grad_b = 0.0
    for x, y in data:
        error = (w * x + b) - y          # prediction minus target
        # Chain rule: d(error²)/dw = 2 * error * x, d(error²)/db = 2 * error
        grad_w += 2 * error * x
        grad_b += 2 * error
    # Step against the gradient to make the loss smaller.
    w -= learning_rate * grad_w / len(data)
    b -= learning_rate * grad_b / len(data)
    if epoch in (1, 10, 50, 200):
        loss = sum(((w * x + b) - y) ** 2 for x, y in data) / len(data)
        print(f"epoch {epoch:>3}: w={w:.3f} b={b:.3f} loss={loss:.4f}")

Resultado esperado

epoch   1: w=0.850 b=0.400 loss=7.0587
epoch  10: w=2.009 b=0.958 loss=0.0009
epoch  50: w=2.005 b=0.989 loss=0.0000
epoch 200: w=2.000 b=1.000 loss=0.0000

Cómo funciona

Para cada punto, el error es la predicción menos el objetivo. La regla de la cadena da el gradiente del error cuadrático, 2·error·x para w y 2·error para b. Al promediar sobre los datos y avanzar contra el gradiente, w y b se acercan a 2 y 1, y la pérdida baja casi a 0.

Cambia los valores y ejecuta el programa en el compilador Python online de CodeUtility sin instalar Python.

Ejercicios prácticos

Modifica las entradas y prueba casos límite antes de usar conjuntos de datos mayores.

  1. Cambia las entradas o los pesos y predice la salida antes de ejecutar.
  2. Imprime los valores intermedios para seguir cada paso del cálculo.
  3. Resuelve los retos enlazados abajo para implementar la idea por tu cuenta.
Ejecutar en el IDE de Python →

Practica con un reto

Usa lo que cubre esta lección para resolver un problema real. Cada reto se ejecuta en el navegador, con pruebas al instante y una revisión de IA.

Todos los retos