La Programación de la Tasa de Aprendizaje (Learning Rate Scheduling) es una estrategia de optimización que permite modificar la tasa de aprendizaje de un modelo durante su entrenamiento.

Su propósito consiste en controlar cómo cambia la magnitud de las actualizaciones de los parámetros a medida que avanza el proceso de aprendizaje.

En Machine Learning, entrenar un modelo implica encontrar parámetros que minimicen una función de pérdida o mejoren un objetivo definido.

Para modificar esos parámetros suelen utilizarse algoritmos basados en gradientes, como Stochastic Gradient Descent (SGD), Momentum, RMSprop, AdaGrad, Adam y AdamW.

Todos estos métodos utilizan, directa o indirectamente, una Learning Rate, o tasa de aprendizaje.

Esta tasa influye en el tamaño de las actualizaciones.

Una tasa demasiado elevada puede provocar oscilaciones, inestabilidad o divergencia.

Una tasa demasiado pequeña puede hacer que el entrenamiento avance lentamente o que el modelo no alcance una solución adecuada dentro del presupuesto disponible.

La dificultad es que una tasa de aprendizaje apropiada al comenzar el entrenamiento no necesariamente sigue siendo la más adecuada durante las etapas posteriores.

Por ejemplo, una red neuronal puede necesitar actualizaciones relativamente grandes al principio para avanzar rápidamente.

Más adelante, cuando se aproxima a una región de menor pérdida, puede beneficiarse de actualizaciones más pequeñas.

Learning Rate Scheduling permite programar este cambio.

En un caso sencillo, podemos comenzar con una tasa de 0,01 y reducirla a la mitad cada diez épocas.

En otros casos, podemos utilizar una función exponencial, una curva de coseno o un programa que aumente progresivamente la tasa durante las primeras actualizaciones antes de reducirla.

También podemos utilizar un scheduler que responda al comportamiento de Validation Loss.

Este último enfoque aparece en estrategias como ReduceLROnPlateau.

La programación de la tasa de aprendizaje es importante en numerosas aplicaciones de Deep Learning, incluidos modelos de visión, clasificadores neuronales, redes recurrentes, Transformers y procedimientos de Fine-Tuning.

En el ámbito de la Visibilidad en Inteligencia Artificial (AI Visibility), puede utilizarse para entrenar clasificadores encargados de identificar menciones, recomendaciones, comparaciones y valoraciones comerciales dentro de respuestas generadas por asistentes de IA.

En este artículo explicamos qué es Learning Rate Scheduling, cómo funciona, sus principales modalidades, sus diferencias con Early Stopping y cómo implementarlo con NumPy, PyTorch y Keras.

¿Qué es Learning Rate Scheduling?

Learning Rate Scheduling es el procedimiento de modificar la tasa de aprendizaje durante el entrenamiento conforme a una regla, programa o señal de rendimiento.

Definición breve: La Programación de la Tasa de Aprendizaje es una técnica de optimización que ajusta la Learning Rate a lo largo del entrenamiento de un modelo para controlar la magnitud de las actualizaciones de sus parámetros y favorecer un proceso de aprendizaje adecuado.

La programación puede depender de:

• Número de épocas.
• Número de pasos del optimizador.
• Fracción del entrenamiento completada.
• Métricas de validación.
• Etapas de Warmup.
• Ciclos de incremento y reducción.

El scheduler no es un optimizador independiente.

Generalmente actúa junto a uno, modificando la tasa utilizada para actualizar los parámetros.

¿Qué significa Learning Rate Scheduler?

Learning Rate Scheduler significa Programador de la Tasa de Aprendizaje.

En la literatura también encontramos:

• Learning Rate Schedule.
• Learning Rate Decay.
• Learning Rate Warmup.
• Cosine Annealing.
• Step Learning Rate.
• Exponential Learning Rate.
• Cyclical Learning Rate.
• One-Cycle Policy.
• Validation-Based Scheduling.
• Learning Rate Annealing.

Estos términos describen diferentes reglas o familias de programación.

No todos implican que Learning Rate disminuya continuamente.

Algunos la aumentan temporalmente, y otros permiten reiniciar ciclos.

¿Por qué es importante Learning Rate?

En el Descenso del Gradiente convencional, la actualización puede escribirse como:

θₜ₊₁ = θₜ − ηₜgₜ

Donde:

• θₜ representa los parámetros del modelo.
• gₜ representa el gradiente actual.
• ηₜ representa Learning Rate en el paso t.

Cuando utilizamos una tasa constante:

ηₜ = η₀

Con Learning Rate Scheduling, la tasa puede variar:

ηₜ = f(t)

O depender de una métrica observada:

ηₜ₊₁ = f(ηₜ, métrica de validación, historial)

La forma exacta depende del scheduler.

¿Qué significa?

El algoritmo de optimización sigue calculando gradientes y actualizando parámetros.

Sin embargo, la magnitud global de las actualizaciones cambia a lo largo del entrenamiento.

Precaución

En optimizadores adaptativos como Adam y AdamW, Learning Rate no determina por sí sola la magnitud de cada actualización.

También influyen los estados de momentos, Weight Decay y otras operaciones.

El scheduler controla la tasa base utilizada por el optimizador.

¿Qué problema intenta resolver?

Imaginemos que entrenamos una red neuronal durante 100 épocas.

Con Learning Rate fija, podemos observar tres situaciones.

Situación 1. Tasa demasiado alta

La pérdida oscila o aumenta.

El entrenamiento puede resultar inestable.

Situación 2. Tasa demasiado baja

La pérdida disminuye lentamente.

El modelo puede necesitar muchas actualizaciones.

Situación 3. Tasa adecuada inicialmente, pero excesiva al final

El modelo aprende bien durante las primeras etapas.

Después continúa realizando actualizaciones que dificultan estabilizarse cerca de una solución.

Learning Rate Scheduling permite modificar el tamaño de los pasos a lo largo del entrenamiento.

¿Garantiza mejor convergencia?

No.

Un scheduler inapropiado también puede perjudicar el aprendizaje.

La programación debe seleccionarse según el modelo, el optimizador y el presupuesto disponible.

Dos categorías principales de schedulers

1. Schedulers predefinidos

La tasa cambia conforme a una función establecida antes del entrenamiento.

Ejemplos:

• Step Decay.
• Exponential Decay.
• Linear Decay.
• Cosine Annealing.
• Polynomial Decay.

Ventaja

La programación resulta predecible.

Limitación

No responde directamente a cambios inesperados del rendimiento de validación.

2. Schedulers basados en métricas

La tasa cambia según los resultados observados.

El ejemplo más conocido es:

ReduceLROnPlateau

Ventaja

Puede responder a periodos donde el modelo deja de mejorar.

Limitación

Las métricas contienen ruido y pueden provocar decisiones prematuras o tardías.

1. Constant Learning Rate

La estrategia más sencilla consiste en mantener Learning Rate fija.

Fórmula

ηₜ = η₀

Ejemplo

Durante 50 épocas:

Learning Rate = 0,001

Ventajas

• Simplicidad.
• Fácil reproducción.
• Baseline claro.
• Menos hiperparámetros.

Limitaciones

La tasa no cambia cuando el entrenamiento necesita ajustes más pequeños o cuando aparece una fase de estabilización.

¿Es siempre inferior a utilizar un scheduler?

No.

En determinados problemas, una tasa constante bien configurada puede funcionar adecuadamente.

Conviene incluirla como baseline.

2. Step Decay

Step Decay reduce la tasa en intervalos discretos.

Fórmula

ηₜ = η₀ × γ^⌊t/k⌋

Donde:

• η₀ es la tasa inicial.
• γ es el factor de reducción.
• k es el número de épocas por intervalo.
• t representa el progreso.

Ejemplo

Learning Rate inicial = 0,1

Factor γ = 0,5

Intervalo = 10 épocas

¿Qué demuestra?

La tasa permanece constante durante un intervalo y después disminuye bruscamente.

Ventaja

Resulta fácil de interpretar.

Limitación

La reducción ocurre en fechas predeterminadas, aunque el modelo todavía estuviera mejorando rápidamente.

3. Multi-Step Decay

Multi-Step Decay reduce la tasa en épocas específicas.

En lugar de utilizar intervalos uniformes, permite definir puntos de cambio.

Ejemplo

Queremos reducir en las épocas:

30, 60 y 80

La tasa cambia solamente al alcanzar esos hitos.

PyTorch

scheduler = torch.optim.lr_scheduler.MultiStepLR(
    optimizer,
    milestones=[30, 60, 80],
    gamma=0.1
)

¿Cuándo puede resultar útil?

Cuando existe una receta de entrenamiento conocida y queremos aplicar reducciones en etapas específicas.

Precaución

Los hitos deben guardar relación con la duración total del entrenamiento.

4. Exponential Decay

Exponential Decay reduce Learning Rate multiplicándola por un factor en cada intervalo.

Fórmula

ηₜ = η₀γᵗ

Para una tasa decreciente convencional:

0 menor que γ menor que 1

Ejemplo

η₀ = 0,01

γ = 0,9

Ventaja

El cambio es gradual y sencillo.

Limitación

Puede reducir la tasa demasiado rápido si gamma es pequeño o el entrenamiento dura muchas iteraciones.

5. Linear Decay

Linear Decay reduce la tasa siguiendo una función lineal.

Una formulación sencilla es:

ηₜ = η₀ + (ηfinal − η₀) × t/T

Para:

0 ≤ t ≤ T

Donde:

• η₀ es la tasa inicial.
• ηfinal es la tasa final.
• T es el número total de pasos del programa.

Ejemplo

Learning Rate inicial:

0,01

Learning Rate final:

0,001

Duración:

100 pasos

En el paso 50:

η₅₀ = 0,0055

¿Qué aporta?

Permite definir una transición predecible entre dos tasas.

Precaución

Debe limitarse correctamente el rango de t para evitar extrapolaciones no deseadas.

6. Cosine Annealing

Cosine Annealing utiliza una curva basada en la función coseno para modificar Learning Rate.

Es una de las estrategias habituales en diferentes procedimientos modernos de entrenamiento.

Fórmula

ηₜ = ηmin + 0,5(ηmax − ηmin)[1 + cos(πt/T)]

Donde:

• ηmax es la tasa superior.
• ηmin es la tasa inferior.
• T representa la duración del descenso.
• t es el progreso dentro del intervalo.

¿Cómo se comporta?

Al comienzo:

η₀ = ηmax

Al terminar:

ηT = ηmin

Entre ambos puntos, la tasa disminuye suavemente.

Ventajas potenciales

• Transición continua.
• Menor brusquedad que Step Decay.
• Flexibilidad para distintos presupuestos.

Limitación

La duración del ciclo debe configurarse según el número de pasos reales.

Un ciclo demasiado corto puede reducir la tasa prematuramente.

7. Cosine Annealing con Warm Restarts

Cosine Annealing Warm Restarts utiliza ciclos de tasa de aprendizaje.

Durante cada ciclo, la tasa disminuye.

Después, el scheduler la eleva nuevamente para comenzar otro ciclo.

¿Por qué se llama Restart?

Porque se reinicia el programa de Learning Rate.

¿Se reinician también los pesos del modelo?

No.

En la formulación convencional de warm restarts, los parámetros entrenados continúan.

No equivale a comenzar un modelo desde cero.

Ejemplo

Ciclo 1:

0,01 → 0,0001

Ciclo 2:

0,01 → 0,0001

PyTorch

scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(
    optimizer,
    T_0=10,
    T_mult=2,
    eta_min=1e-5
)

¿Qué significa T_0?

Es la duración del primer ciclo, medida en las unidades con las que avanzamos el scheduler.

¿Qué significa T_mult?

Controla cómo cambia la duración de los ciclos posteriores.

Precaución

Los reinicios de Learning Rate no garantizan escapar de mínimos locales ni obtener mejor generalización.

8. Linear Warmup

Learning Rate Warmup es una etapa inicial durante la que Learning Rate aumenta progresivamente.

Ejemplo

Un modelo utiliza:

Tasa inicial = 0,00001

Tasa objetivo = 0,001

Durante los primeros 1.000 pasos, la tasa aumenta.

Fórmula

ηₜ = ηinicio + (ηobjetivo − ηinicio)(t/W)

Para:

0 ≤ t ≤ W

Donde W es la duración del Warmup.

¿Por qué utilizar Warmup?

En determinados entrenamientos, las primeras actualizaciones pueden ser especialmente sensibles.

Warmup permite comenzar con pasos más pequeños y aumentar gradualmente la tasa.

Aplicaciones

• Transformers.
• Fine-Tuning.
• Entrenamiento con lotes grandes.
• Arquitecturas sensibles al comienzo del entrenamiento.

Precaución

Warmup no es obligatorio.

En modelos sencillos puede añadir complejidad sin beneficios apreciables.

9. Warmup seguido de Cosine Decay

Una estrategia frecuente combina dos etapas.

Etapa 1. Warmup

Learning Rate aumenta progresivamente.

Etapa 2. Cosine Decay

Learning Rate disminuye suavemente.

Ejemplo

Duración total:

10.000 pasos

Warmup:

1.000 pasos

Cosine Decay:

9.000 pasos restantes

¿Qué aporta?

Separa la estabilización inicial del descenso posterior.

¿Por qué puede resultar útil para Transformers?

Porque ciertas configuraciones de entrenamiento de Transformers son sensibles a las actualizaciones iniciales y se benefician de una programación controlada.

Precaución

Los beneficios dependen del modelo.

No debe suponerse que el mismo porcentaje de Warmup es apropiado en todos los casos.

10. ReduceLROnPlateau

ReduceLROnPlateau es un scheduler que reduce Learning Rate cuando una métrica deja de mejorar suficientemente durante un intervalo.

A diferencia de Step Decay o Cosine Annealing, responde al comportamiento observado.

Ejemplo

Monitorizamos:

Validation Loss

Configuramos:

patience = 3

factor = 0,5

Si la pérdida deja de mejorar según el criterio del scheduler durante el intervalo configurado, Learning Rate se reduce.

Ejemplo

Tasa actual:

0,001

Después de una reducción:

0,0005

¿Qué significa factor?

Es el multiplicador aplicado a la tasa actual.

¿Qué significa patience?

Es la tolerancia a periodos sin mejora antes de activar una reducción.

Precaución

La interpretación exacta del contador puede depender de la implementación.

En PyTorch, threshold, threshold_mode, cooldown, min_lr y eps también influyen en el comportamiento.

11. Cyclical Learning Rates

Cyclical Learning Rates (CLR) es una familia de políticas donde la tasa varía entre límites inferiores y superiores.

Ejemplo

Learning Rate oscila entre:

0,0001

y

0,01

¿Por qué utilizar ciclos?

Permiten estudiar regiones diferentes del paisaje de optimización y modificar la magnitud de las actualizaciones a lo largo del entrenamiento.

Tipos relacionados

• Triangular Policy.
• Triangular2.
• Exponential Range.

¿Cyclical Learning Rate equivale a Cosine Annealing?

No.

Ambos pueden utilizar ciclos, pero sus funciones y reglas de cambio pueden ser diferentes.

12. One-Cycle Policy

One-Cycle Policy es una estrategia donde Learning Rate aumenta inicialmente hasta un máximo y después disminuye hacia un valor bajo.

Etapas conceptuales

Etapa 1: aumento de Learning Rate.

Etapa 2: reducción progresiva.

En algunas configuraciones existen tres fases.

¿Qué significa pct_start?

Determina qué fracción del ciclo se dedica a la etapa de incremento inicial.

¿One-Cycle también modifica Momentum?

Puede hacerlo.

La implementación de PyTorch permite utilizar una política donde Momentum cambia inversamente a Learning Rate, siempre que el optimizador y la configuración sean compatibles.

Precaución importante

OneCycleLR se actualiza después de cada mini-batch que efectivamente produce un paso del optimizador.

No debe llamarse solamente una vez por época cuando se ha configurado con pasos por mini-batch.

Comparación de las principales estrategias

La frecuencia real depende de cómo se diseñe y configure cada entrenamiento.

Ejemplo 1 — Implementar schedulers desde cero con NumPy

Vamos a comparar varias estrategias sobre un mismo intervalo.

import numpy as np
import matplotlib.pyplot as plt
initial_lr = 0.01
final_lr = 0.0001
total_steps = 100
steps = np.arange(total_steps + 1)
# 1. Constant
constant = np.full_like(
    steps,
    initial_lr,
    dtype=float
)
# 2. Step Decay
step_decay = (
    initial_lr
    * 0.5 ** (steps // 20)
)
# 3. Exponential Decay
exponential = (
    initial_lr
    * 0.97 ** steps
)
# 4. Linear Decay
linear = (
    initial_lr
    + (final_lr - initial_lr)
    * steps / total_steps
)
# 5. Cosine Annealing
cosine = (
    final_lr
    + 0.5 * (initial_lr - final_lr)
    * (
        1 + np.cos(
            np.pi * steps / total_steps
        )
    )
)
plt.figure(figsize=(11, 6))
plt.plot(
    steps,
    constant,
    label="Constant"
)
plt.plot(
    steps,
    step_decay,
    label="Step Decay"
)
plt.plot(
    steps,
    exponential,
    label="Exponential Decay"
)
plt.plot(
    steps,
    linear,
    label="Linear Decay"
)
plt.plot(
    steps,
    cosine,
    label="Cosine Annealing"
)
plt.xlabel("Paso")
plt.ylabel("Learning Rate")
plt.title(
    "Comparación de Learning Rate Schedulers"
)
plt.legend()
plt.grid(True)
plt.show()

¿Qué demuestra?

El código permite observar cómo cambia la tasa según la política seleccionada.

Interpretación

Step Decay presenta descensos bruscos.

Exponential Decay produce un descenso multiplicativo.

Linear Decay sigue una recta.

Cosine Annealing produce una curva suave.

Precaución

El gráfico representa funciones de Learning Rate.

No demuestra qué estrategia produce el mejor modelo.

Ejemplo 2 — Warmup con Cosine Decay en Python

Vamos a construir una función que combine ambas etapas.

import math
import numpy as np
import matplotlib.pyplot as plt
def warmup_cosine(
    step,
    total_steps,
    warmup_steps,
    start_lr,
    peak_lr,
    min_lr
):
    if not (
        0 < warmup_steps < total_steps
    ):
        raise ValueError(
            "Se requiere 0 < warmup_steps < total_steps"
        )
    step = max(
        0,
        min(step, total_steps)
    )
    if step < warmup_steps:
        fraction = step / warmup_steps
        return (
            start_lr
            + (peak_lr - start_lr)
            * fraction
        )
    progress = (
        (step - warmup_steps)
        / (total_steps - warmup_steps)
    )
    cosine = 0.5 * (
        1 + math.cos(math.pi * progress)
    )
    return (
        min_lr
        + (peak_lr - min_lr) * cosine
    )
total_steps = 1000
warmup_steps = 100
values = [
    warmup_cosine(
        step=step,
        total_steps=total_steps,
        warmup_steps=warmup_steps,
        start_lr=1e-5,
        peak_lr=1e-3,
        min_lr=1e-5
    )
    for step in range(total_steps + 1)
]
plt.figure(figsize=(10, 5))
plt.plot(values)
plt.axvline(
    warmup_steps,
    linestyle="--",
    label="Fin de Warmup"
)
plt.xlabel("Optimizer Step")
plt.ylabel("Learning Rate")
plt.title(
    "Linear Warmup + Cosine Decay"
)
plt.legend()
plt.grid(True)
plt.show()

¿Qué demuestra?

La tasa comienza en un valor pequeño.

Después aumenta hasta un máximo.

Finalmente disminuye suavemente.

¿Por qué es relevante?

Este patrón aparece en diferentes recetas de entrenamiento y Fine-Tuning de redes profundas.

Learning Rate Scheduling en PyTorch

PyTorch ofrece diferentes schedulers bajo:

torch.optim.lr_scheduler

Entre ellos:

• StepLR.
• MultiStepLR.
• ExponentialLR.
• CosineAnnealingLR.
• CosineAnnealingWarmRestarts.
• LinearLR.
• SequentialLR.
• ReduceLROnPlateau.
• CyclicLR.
• OneCycleLR.

La mayoría recibe un optimizador y modifica su Learning Rate según las reglas configuradas.

Ejemplo 3 — StepLR con PyTorch

import torch
import torch.nn as nn
model = nn.Linear(20, 1)
optimizer = torch.optim.SGD(
    model.parameters(),
    lr=0.1,
    momentum=0.9
)
scheduler = torch.optim.lr_scheduler.StepLR(
    optimizer,
    step_size=10,
    gamma=0.5
)
for epoch in range(30):
    current_lr = optimizer.param_groups[0]["lr"]
    print(
        f"Época {epoch + 1}: "
        f"LR={current_lr:.6f}"
    )
    # Ejecutar entrenamiento de una época:
    # optimizer.zero_grad()
    # loss.backward()
    # optimizer.step()
    scheduler.step()

¿Qué demuestra?

La tasa disminuye cada diez llamadas a scheduler.step().

Precaución

Este código es ilustrativo y no ejecuta entrenamiento real.

En un ciclo completo, debe llamarse al scheduler después de las actualizaciones del optimizador.

La documentación de PyTorch recomienda ese orden.

Ejemplo 4 — ExponentialLR con PyTorch

import torch
optimizer = torch.optim.Adam(
    model.parameters(),
    lr=0.001
)
scheduler = torch.optim.lr_scheduler.ExponentialLR(
    optimizer,
    gamma=0.95
)

Después de cada época completa:

scheduler.step()

¿Qué ocurre?

La Learning Rate se multiplica por 0,95 cada vez que avanza el scheduler.

¿Por qué puede resultar útil?

Permite reducir gradualmente la tasa sin cambios bruscos.

Ejemplo 5 — CosineAnnealingLR con PyTorch

optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=0.001,
    weight_decay=0.01
)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
    optimizer,
    T_max=50,
    eta_min=1e-5
)

¿Qué significa T_max?

Representa la duración configurada del descenso, en unidades de llamadas al scheduler.

¿Qué significa eta_min?

Es la tasa mínima del ciclo.

Precaución

Si llamamos al scheduler por época, T_max=50 representa 50 avances asociados a épocas.

Si decidimos actualizarlo por paso del optimizador, el valor debe expresarse en ese número de pasos.

Ejemplo 6 — Warmup + Cosine Annealing en PyTorch

Podemos utilizar LinearLR y SequentialLR.

import torch
model = torch.nn.Linear(20, 1)
optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=0.001
)
warmup = torch.optim.lr_scheduler.LinearLR(
    optimizer,
    start_factor=0.1,
    end_factor=1.0,
    total_iters=5
)
cosine = torch.optim.lr_scheduler.CosineAnnealingLR(
    optimizer,
    T_max=45,
    eta_min=1e-5
)
scheduler = torch.optim.lr_scheduler.SequentialLR(
    optimizer,
    schedulers=[warmup, cosine],
    milestones=[5]
)

¿Qué hace?

Durante los cinco primeros avances del scheduler, aplica el programa de Warmup.

Después utiliza Cosine Annealing.

¿Cómo integrarlo?

Si el diseño utiliza un avance por época:

for epoch in range(50):
    # train_one_epoch(...)
    # Con actualizaciones reales del optimizador
    scheduler.step()

Precaución

No conviene asumir que cinco épocas de Warmup tienen el mismo efecto que cinco pasos de optimizador.

La unidad de programación debe definirse explícitamente.

Ejemplo 7 — ReduceLROnPlateau en PyTorch

optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=0.001
)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
    optimizer,
    mode="min",
    factor=0.5,
    patience=3,
    threshold=1e-4,
    threshold_mode="rel",
    cooldown=1,
    min_lr=1e-6
)

Después de evaluar Validation Loss:

scheduler.step(val_loss)

¿Qué significa mode=»min»?

La métrica mejora cuando disminuye.

¿Qué significa threshold_mode=»rel»?

La mejora significativa se evalúa mediante un umbral relativo.

¿Qué significa cooldown?

Permite esperar un intervalo después de una reducción antes de volver a aplicar determinadas decisiones del scheduler.

¿Qué significa min_lr?

Limita la tasa mínima.

¿Por qué no llamarlo después de cada mini-batch?

Porque en este ejemplo está diseñado para utilizar una métrica de validación calculada al terminar una época.

La llamada debe realizarse cuando esa métrica esté disponible.

Ejemplo 8 — OneCycleLR con PyTorch

OneCycleLR se configura según el número de pasos reales del entrenamiento.

import torch
model = torch.nn.Linear(20, 2)
optimizer = torch.optim.SGD(
    model.parameters(),
    lr=0.001,
    momentum=0.9
)
epochs = 10
steps_per_epoch = 100
scheduler = torch.optim.lr_scheduler.OneCycleLR(
    optimizer,
    max_lr=0.05,
    epochs=epochs,
    steps_per_epoch=steps_per_epoch,
    pct_start=0.3,
    anneal_strategy="cos"
)

En el entrenamiento real:

for epoch in range(epochs):
    for xb, yb in train_loader:
        optimizer.zero_grad()
        logits = model(xb)
        loss = criterion(logits, yb)
        loss.backward()
        optimizer.step()
        scheduler.step()

¿Qué demuestra?

OneCycleLR modifica la tasa después de cada actualización.

Precaución importante

steps_per_epoch debe coincidir con el número real de pasos del optimizador.

Si utilizamos Gradient Accumulation, el número de mini-batches puede ser diferente del número de actualizaciones efectivas.

Además, no debe ejecutarse scheduler.step() cuando no se ha realizado realmente una actualización que corresponda al programa.

Ejemplo 9 — Entrenamiento completo con Cosine Annealing y Early Stopping

Vamos a entrenar un clasificador binario con:

• Datos sintéticos.
• Separación Train/Validation/Test.
• Estandarización.
• AdamW.
• CosineAnnealingLR.
• Early Stopping.
• Restauración del mejor modelo.
• Evaluación independiente.

Instalación

pip install numpy scikit-learn torch

Código completo

import copy
import math
import torch
import torch.nn as nn
from torch.utils.data import (
    TensorDataset,
    DataLoader
)
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report
torch.manual_seed(42)
# 1. Crear dataset sintético
X, y = make_classification(
    n_samples=2400,
    n_features=20,
    n_informative=12,
    n_redundant=4,
    weights=[0.65, 0.35],
    flip_y=0.03,
    random_state=42
)
# 2. Reservar Test Set
X_dev, X_test, y_dev, y_test = train_test_split(
    X,
    y,
    test_size=0.20,
    stratify=y,
    random_state=42
)
# 3. Crear Train y Validation
X_train, X_val, y_train, y_val = train_test_split(
    X_dev,
    y_dev,
    test_size=0.25,
    stratify=y_dev,
    random_state=42
)
# 4. Estandarización sin fuga de datos
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_val = scaler.transform(X_val)
X_test = scaler.transform(X_test)
def to_x(values):
    return torch.tensor(
        values,
        dtype=torch.float32
    )
def to_y(values):
    return torch.tensor(
        values.reshape(-1, 1),
        dtype=torch.float32
    )
train_loader = DataLoader(
    TensorDataset(
        to_x(X_train),
        to_y(y_train)
    ),
    batch_size=32,
    shuffle=True
)
X_val_t = to_x(X_val)
y_val_t = to_y(y_val)
X_test_t = to_x(X_test)
# 5. Arquitectura
model = nn.Sequential(
    nn.Linear(20, 64),
    nn.ReLU(),
    nn.Dropout(0.1),
    nn.Linear(64, 32),
    nn.ReLU(),
    nn.Linear(32, 1)
)
criterion = nn.BCEWithLogitsLoss()
# 6. Optimizador
optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=0.001,
    weight_decay=0.01
)
# 7. Scheduler por época
max_epochs = 100
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
    optimizer,
    T_max=max_epochs,
    eta_min=1e-5
)
# 8. Early Stopping
best_val_loss = float("inf")
best_model_state = None
best_epoch = None
patience = 12
min_delta = 0.0001
wait = 0
history = {
    "train_loss": [],
    "val_loss": [],
    "learning_rate": []
}
# 9. Entrenamiento
for epoch in range(1, max_epochs + 1):
    model.train()
    total_loss = 0.0
    total_examples = 0
    current_lr = optimizer.param_groups[0]["lr"]
    for xb, yb in train_loader:
        optimizer.zero_grad()
        logits = model(xb)
        loss = criterion(logits, yb)
        loss.backward()
        optimizer.step()
        total_loss += (
            loss.item() * len(xb)
        )
        total_examples += len(xb)
    train_loss = (
        total_loss / total_examples
    )
    # 10. Validación
    model.eval()
    with torch.inference_mode():
        val_logits = model(X_val_t)
        val_loss = criterion(
            val_logits,
            y_val_t
        ).item()
    if not math.isfinite(val_loss):
        print("Validation Loss no finita.")
        break
    history["train_loss"].append(train_loss)
    history["val_loss"].append(val_loss)
    history["learning_rate"].append(current_lr)
    # 11. Selección del mejor modelo
    if val_loss < best_val_loss - min_delta:
        best_val_loss = val_loss
        best_epoch = epoch
        best_model_state = copy.deepcopy(
            model.state_dict()
        )
        wait = 0
    else:
        wait += 1
    if epoch == 1 or epoch % 10 == 0:
        print(
            f"Epoch {epoch:03d} | "
            f"Train={train_loss:.4f} | "
            f"Val={val_loss:.4f} | "
            f"LR={current_lr:.6f}"
        )
    # 12. Controlar parada
    if wait >= patience:
        print(
            "Early Stopping en época:",
            epoch
        )
        break
    # Actualizar LR para la próxima época
    scheduler.step()
# 13. Restaurar mejor estado
if best_model_state is None:
    raise RuntimeError(
        "No se encontró un modelo válido."
    )
model.load_state_dict(best_model_state)
model.eval()
print("Mejor época:", best_epoch)
print("Mejor Validation Loss:", best_val_loss)
# 14. Evaluación final
with torch.inference_mode():
    test_logits = model(X_test_t)
    probabilities = torch.sigmoid(
        test_logits
    ).numpy().ravel()
    predictions = (
        probabilities >= 0.5
    ).astype(int)
print(classification_report(
    y_test,
    predictions,
    zero_division=0
))

¿Qué demuestra este experimento?

El modelo utiliza AdamW para modificar sus parámetros.

CosineAnnealingLR reduce progresivamente la tasa al finalizar cada época completada.

Early Stopping observa la pérdida de validación.

Cuando deja de mejorar durante suficientes épocas, el entrenamiento termina.

Finalmente, se restaura el mejor estado del modelo y se evalúa sobre un Test Set independiente.

Limitaciones

El programa utiliza datos sintéticos y una sola partición.

No demuestra que Cosine Annealing sea superior a una tasa fija.

Tampoco restaura automáticamente el estado del optimizador y el scheduler correspondiente a la mejor época.

Para reanudar exactamente desde esa época sería necesario guardar un checkpoint completo.

Learning Rate Scheduling en Keras

Keras ofrece dos mecanismos principales.

1. Objetos LearningRateSchedule

Permiten definir funciones de tasa de aprendizaje que el optimizador evalúa durante el entrenamiento.

Ejemplos:

• ExponentialDecay.
• PiecewiseConstantDecay.
• PolynomialDecay.
• InverseTimeDecay.
• CosineDecay.
• CosineDecayRestarts.

2. Callbacks

Permiten modificar Learning Rate durante el procedimiento de entrenamiento.

Entre ellos:

• LearningRateScheduler.
• ReduceLROnPlateau.

Diferencia importante

Los objetos de schedule suelen utilizar el número de pasos del optimizador.

Los callbacks pueden operar según épocas o métricas, dependiendo de su implementación.

Ejemplo 10 — ExponentialDecay en Keras

import keras
from keras import layers
schedule = keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate=0.001,
    decay_steps=1000,
    decay_rate=0.9,
    staircase=False
)
optimizer = keras.optimizers.Adam(
    learning_rate=schedule
)
model = keras.Sequential([
    layers.Input(shape=(20,)),
    layers.Dense(64, activation="relu"),
    layers.Dense(1)
])
model.compile(
    optimizer=optimizer,
    loss=keras.losses.BinaryCrossentropy(
        from_logits=True
    )
)

¿Qué significa decay_steps?

Define la escala de pasos utilizada por el programa exponencial.

¿Qué significa staircase?

Cuando es verdadero, el descenso se aplica en escalones conforme a la división entera del progreso.

Cuando es falso, puede variar continuamente entre esos intervalos.

Ejemplo 11 — CosineDecay con Warmup en Keras

Keras permite configurar Warmup directamente dentro de CosineDecay.

import keras
schedule = keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=1e-5,
    warmup_target=1e-3,
    warmup_steps=500,
    decay_steps=4500,
    alpha=0.01
)
optimizer = keras.optimizers.AdamW(
    learning_rate=schedule,
    weight_decay=0.01
)

¿Qué significa?

La tasa comienza en 1e-5.

Aumenta hasta 1e-3 durante 500 pasos.

Después sigue un descenso por coseno durante 4.500 pasos adicionales.

La tasa final del descenso es una fracción del máximo.

¿Qué significa alpha en este caso?

Controla la fracción mínima de la tasa utilizada por CosineDecay.

No es el mismo parámetro alpha del optimizador RMSprop.

Precaución

decay_steps corresponde al intervalo del descenso de coseno, no al total incluyendo Warmup.

Por tanto, en este ejemplo el programa completo utiliza 5.000 pasos antes de alcanzar su mínimo.

Ejemplo 12 — ReduceLROnPlateau en Keras

import keras
reduce_lr = keras.callbacks.ReduceLROnPlateau(
    monitor="val_loss",
    factor=0.5,
    patience=4,
    min_delta=0.0001,
    cooldown=1,
    min_lr=1e-6,
    verbose=1
)

Después:

history = model.fit(
    X_train,
    y_train,
    validation_data=(X_val, y_val),
    epochs=100,
    batch_size=32,
    callbacks=[reduce_lr]
)

¿Qué demuestra?

El callback monitoriza Validation Loss.

Cuando se cumple su criterio de estancamiento, reduce la tasa.

Precaución

Este procedimiento presupone que el optimizador dispone de una tasa modificable por el callback.

No conviene combinarlo indiscriminadamente con un objeto LearningRateSchedule que también gobierne la misma tasa.

Debe elegirse una estrategia coherente para evitar conflictos entre mecanismos.

Ejemplo 13 — LearningRateScheduler en Keras

Podemos definir nuestra propia función.

import keras
def schedule(epoch, current_lr):
    if epoch < 10:
        return float(current_lr)
    return float(current_lr * 0.95)
callback = keras.callbacks.LearningRateScheduler(
    schedule=schedule,
    verbose=1
)

¿Qué demuestra?

La función recibe la época actual y la tasa vigente.

Puede calcular una nueva tasa según una regla propia.

Precaución

La firma y las unidades de la función deben seguir la documentación del callback utilizado.

Learning Rate Scheduling frente a Early Stopping

Ambas técnicas controlan aspectos diferentes del entrenamiento.

Learning Rate Scheduling

Modifica la magnitud de las actualizaciones.

Early Stopping

Decide cuándo detener el entrenamiento.

¿Pueden combinarse?

Sí.

Por ejemplo:

ReduceLROnPlateau patience = 3

EarlyStopping patience = 10

Así, el scheduler puede tener oportunidades de reducir la tasa antes de detener el entrenamiento.

¿Garantiza una nueva mejora?

No.

La coordinación solamente permite una secuencia de decisiones apropiada.

Learning Rate Scheduling y SGD

SGD suele ser sensible a Learning Rate.

Los schedulers permiten reducir las actualizaciones durante el entrenamiento.

Ejemplo

Una CNN utiliza SGD con Momentum y Step Decay.

¿Por qué puede resultar útil?

Porque Momentum acumula información histórica y la tasa determina la magnitud con la que se aplica esa información.

Precaución

Un descenso demasiado rápido puede producir aprendizaje insuficiente.

Learning Rate Scheduling y Adam

Adam utiliza estadísticas adaptativas por parámetro.

Sin embargo, también depende de una tasa base.

¿Es necesario programarla?

No necesariamente en todos los problemas.

Pero puede resultar útil.

Ejemplo

Un clasificador comienza con Adam a una tasa relativamente alta y utiliza Cosine Decay.

Importante

La adaptación individual de Adam no sustituye automáticamente una programación global apropiada.

Learning Rate Scheduling y AdamW

AdamW combina actualizaciones adaptativas con Weight Decay desacoplada.

¿Cómo interactúa Learning Rate?

En la formulación convencional de AdamW, el factor de reducción directa de parámetros incluye el producto:

ηₜ × λ

Donde λ es Weight Decay.

Por tanto, cambiar la tasa también cambia la reducción directa por paso.

¿Por qué importa?

Dos entrenamientos con igual coeficiente de Weight Decay pueden presentar efectos acumulados diferentes si sus programas de Learning Rate y números de pasos difieren.

Buena práctica

Registrar el scheduler junto a los demás hiperparámetros.

Learning Rate Scheduling y Gradient Accumulation

Gradient Accumulation permite reunir gradientes de varios mini-batches antes de realizar una actualización.

Problema potencial

Un entrenamiento puede procesar 100 mini-batches, pero realizar solamente 25 pasos del optimizador.

Si el scheduler está definido por pasos efectivos, debe avanzar 25 veces.

Ejemplo

Con acumulación de cuatro mini-batches:

4 mini-batches → 1 optimizer.step()

¿Por qué importa?

Si el scheduler avanza después de cada mini-batch, pero el optimizador solamente se actualiza cada cuatro, Learning Rate podría recorrer su programa mucho más rápido de lo previsto.

Recomendación

Definir claramente la unidad de programación.

Para schedulers por paso, sincronizar el avance con las actualizaciones reales del optimizador.

Learning Rate Scheduling y Mixed Precision

Mixed Precision puede utilizar escalado de gradientes en determinados entrenamientos.

En ciertas implementaciones, un paso del optimizador puede omitirse debido a gradientes no finitos.

¿Por qué importa?

Si el paso del optimizador no se ejecuta, avanzar un scheduler definido por pasos efectivos puede desincronizar su progreso.

Buena práctica

Cuando se utiliza precisión mixta, controlar si realmente ocurrió la actualización.

La lógica concreta depende del framework y del mecanismo de escalado empleado.

Learning Rate Scheduling en Transformers

Los Transformers utilizan diferentes estrategias de Learning Rate Scheduling.

Entre ellas encontramos:

• Linear Warmup.
• Linear Decay.
• Cosine Decay.
• Inverse Square Root Decay.
• Programas personalizados.

¿Por qué Warmup?

En determinadas configuraciones, las primeras actualizaciones pueden resultar sensibles.

Un incremento gradual puede facilitar el comienzo del entrenamiento.

¿Por qué reducir después?

Una tasa menor puede favorecer etapas posteriores de ajuste.

¿Es universal para todos los Transformers?

No.

La programación apropiada depende de la arquitectura, el dataset y el procedimiento de entrenamiento.

¿Qué es Inverse Square Root Scheduling?

Algunos procedimientos utilizan una tasa que disminuye aproximadamente según la raíz cuadrada inversa del número de pasos.

Fórmula conceptual

ηₜ ∝ 1/√t

Después de una etapa de Warmup pueden utilizarse variantes que combinan aumento inicial y descenso mediante raíz inversa.

¿Por qué es importante?

Este tipo de programación aparece en investigaciones relacionadas con arquitecturas Transformer.

Precaución

La constante de proporcionalidad y el tratamiento del periodo inicial son esenciales para definir el programa completo.

Learning Rate Scheduling en Fine-Tuning de LLM

Durante el ajuste fino de modelos de lenguaje, los parámetros ya contienen información aprendida.

Por esta razón, el procedimiento puede necesitar actualizaciones relativamente pequeñas.

Estrategia posible

• Tasa inicial baja.
• Warmup breve.
• Cosine Decay.
• Evaluación periódica.
• Early Stopping cuando corresponda.

¿Por qué es importante?

Porque una tasa demasiado elevada puede deteriorar el comportamiento del modelo preentrenado.

Precaución

La menor Validation Loss no garantiza automáticamente mejores capacidades de razonamiento, exactitud factual o seguimiento de instrucciones.

La evaluación debe incluir las tareas relevantes.

Learning Rate Scheduling y LoRA

LoRA utiliza parámetros de adaptación de bajo rango.

Estos parámetros pueden entrenarse con AdamW u otros optimizadores.

¿Se pueden utilizar schedulers?

Sí.

¿Debe utilizarse el mismo programa que en Fine-Tuning completo?

No necesariamente.

El número de parámetros entrenables, las tasas adecuadas y las condiciones de optimización pueden ser diferentes.

Buena práctica

Seleccionar la programación mediante validación específica del método utilizado.

¿Por qué es importante Learning Rate Scheduling para AI Visibility?

Una plataforma de AI Visibility puede entrenar clasificadores neuronales que analicen respuestas comerciales.

Entre las tareas posibles encontramos:

• Detección de menciones de marcas.
• Clasificación de recomendaciones.
• Identificación de comparaciones.
• Detección de valoraciones negativas.
• Clasificación de afirmaciones.
• Identificación de atributos de productos.

Estos modelos pueden beneficiarse de una programación apropiada de Learning Rate.

Ejemplo empresarial

Una respuesta indica:

«MarcaA es una alternativa interesante, pero recomendaría MarcaB por sus integraciones».

El clasificador debe distinguir:

• Mención de MarcaA.
• Valoración contextual de MarcaA.
• Recomendación explícita de MarcaB.
• Relación comparativa.

El scheduler no interpreta directamente el texto.

Controla la tasa de las actualizaciones durante el entrenamiento del modelo encargado de realizar esa clasificación.

Ejemplo 14 — Clasificador de AI Visibility con Warmup y Cosine Decay

Vamos a definir un clasificador con entradas de 384 dimensiones.

Usaremos AdamW y una política de tasa basada en pasos.

import math
import torch
import torch.nn as nn
class VisibilityClassifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(384, 128),
            nn.LayerNorm(128),
            nn.GELU(),
            nn.Dropout(0.2),
            nn.Linear(128, 64),
            nn.GELU(),
            nn.Linear(64, 4)
        )
    def forward(self, x):
        return self.network(x)
model = VisibilityClassifier()
optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=0.001,
    weight_decay=0.01
)
warmup_steps = 100
total_steps = 1000
def lr_multiplier(step):
    if step < warmup_steps:
        return (
            0.1
            + 0.9 * step / warmup_steps
        )
    progress = (
        (step - warmup_steps)
        / (total_steps - warmup_steps)
    )
    progress = min(1.0, max(0.0, progress))
    return (
        0.01
        + 0.99
        * 0.5
        * (1 + math.cos(math.pi * progress))
    )
scheduler = torch.optim.lr_scheduler.LambdaLR(
    optimizer,
    lr_lambda=lr_multiplier
)
criterion = nn.CrossEntropyLoss()
# En un entrenamiento real:
# for xb, labels in train_loader:
#     optimizer.zero_grad()
#     logits = model(xb)
#     loss = criterion(logits, labels)
#     loss.backward()
#     optimizer.step()
#     scheduler.step()

¿Qué demuestra?

El programa construye un scheduler con dos etapas.

Primero incrementa la tasa.

Después la reduce mediante una curva basada en coseno.

Precaución

El número total de pasos debe corresponder con el entrenamiento real.

Además, es necesario disponer de embeddings y etiquetas reales para entrenar un clasificador útil.

¿Learning Rate Scheduling aumenta Recommendation Rate?

Recommendation Rate representa la frecuencia de recomendaciones observadas bajo una metodología definida.

Learning Rate Scheduling es una técnica de entrenamiento.

Relación indirecta

Una programación apropiada podría contribuir a entrenar un clasificador con menor error.

Esto podría mejorar la calidad de la medición.

Lo que no hace

No aumenta directamente la frecuencia con la que ChatGPT, Gemini, Claude o Perplexity recomiendan una marca.

Tampoco modifica automáticamente las respuestas generadas por esos asistentes.

Learning Rate Scheduling y Citation Coverage

Un clasificador puede utilizarse para identificar determinadas citas o referencias en respuestas.

Learning Rate Scheduling puede intervenir en su entrenamiento.

Sin embargo, Citation Coverage depende de la presencia real de referencias y de la metodología utilizada para contarlas.

Optimizar el entrenamiento del clasificador no crea automáticamente nuevas citas.

¿Cómo evaluar diferentes schedulers?

Podemos comparar:

Modelo A: Constant Learning Rate.

Modelo B: Step Decay.

Modelo C: Exponential Decay.

Modelo D: Cosine Annealing.

Modelo E: Warmup + Cosine Decay.

Modelo F: ReduceLROnPlateau.

Procedimiento recomendado

1. Utilizar una arquitectura común.
2. Mantener las mismas particiones de datos.
3. Controlar la inicialización.
4. Definir presupuestos comparables.
5. Configurar correctamente el número de pasos.
6. Registrar Learning Rate real durante entrenamiento.
7. Evaluar varias semillas.
8. Seleccionar mediante validación.
9. Medir métricas predictivas.
10. Evaluar finalmente sobre Test Set independiente.

Métricas recomendadas

• Training Loss.
• Validation Loss.
• Macro-F1.
• Precision.
• Recall.
• Tiempo de entrenamiento.
• Número de pasos.
• Mejor época.
• Variabilidad entre ejecuciones.

¿Por qué registrar Learning Rate?

Porque permite comprobar que la programación realmente se ejecutó según lo previsto.

También ayuda a identificar errores de configuración.

Errores frecuentes al utilizar Learning Rate Scheduling

Error 1. Confundir scheduler con optimizador

Cumplen funciones diferentes.

Error 2. Llamar scheduler.step() antes de optimizer.step()

Puede omitir el primer valor previsto del programa en PyTorch.

Error 3. Actualizar OneCycleLR por época

Está diseñado para avanzar por batch o paso efectivo del optimizador.

Error 4. Utilizar T_max con unidades incorrectas

Puede reducir la tasa demasiado rápido o demasiado lentamente.

Error 5. Ignorar Gradient Accumulation

Puede desincronizar el scheduler del número real de actualizaciones.

Error 6. Configurar Warmup excesivamente largo

Puede consumir demasiado presupuesto con una tasa pequeña.

Error 7. Reducir la tasa demasiado pronto

Puede impedir mejoras posteriores.

Error 8. Configurar min_lr inapropiado

Puede permitir una tasa demasiado pequeña o impedir reducciones necesarias.

Error 9. Combinar varios schedulers sin comprender su interacción

Puede producir un comportamiento inesperado.

Error 10. Confundir ReduceLROnPlateau con Early Stopping

Uno reduce la tasa; el otro detiene entrenamiento.

Error 11. Suponer que Warm Restarts reinicia el modelo

Normalmente reinicia la programación, no los parámetros.

Error 12. No guardar el estado del scheduler

Puede dificultar reanudar un entrenamiento.

Error 13. No registrar el número de pasos

Impide reconstruir correctamente el programa.

Error 14. Utilizar el Test Set para seleccionar la política

Contamina la evaluación final.

Error 15. Suponer que Cosine Decay siempre mejora el rendimiento

No existe una garantía universal.

Buenas prácticas para Learning Rate Scheduling

Para utilizar correctamente esta técnica conviene:

1. Comenzar con un baseline de Learning Rate constante.
2. Definir el objetivo de la programación.
3. Identificar el optimizador utilizado.
4. Establecer claramente épocas y pasos.
5. Sincronizar el scheduler con las actualizaciones reales.
6. Utilizar Warmup cuando exista una justificación.
7. Coordinar ReduceLROnPlateau y Early Stopping.
8. Registrar Learning Rate durante el entrenamiento.
9. Guardar estados del optimizador y scheduler.
10. Controlar Gradient Accumulation.
11. Revisar Mixed Precision.
12. Comparar múltiples semillas.
13. Mantener un Test Set independiente.
14. Analizar métricas de validación.
15. Documentar la versión de las bibliotecas.

En AI Visibility también es conveniente evaluar la generalización por marca, plataforma, idioma y periodo.

Preguntas frecuentes sobre Learning Rate Scheduling

¿Qué significa Learning Rate Scheduling?

Significa Programación de la Tasa de Aprendizaje.

¿Para qué sirve?

Sirve para cambiar Learning Rate durante entrenamiento según un programa o una señal de rendimiento.

¿Qué es un Learning Rate Scheduler?

Es un componente que modifica la tasa utilizada por un optimizador.

¿Un scheduler es un optimizador?

No.

¿Por qué cambiar Learning Rate?

Porque una tasa apropiada al inicio no necesariamente es adecuada durante todo el entrenamiento.

¿Qué es Constant Learning Rate?

Es mantener una tasa fija.

¿Qué es Step Decay?

Es reducir Learning Rate en intervalos discretos.

¿Qué es MultiStepLR?

Es un scheduler que aplica reducciones en hitos configurados.

¿Qué es Exponential Decay?

Es una reducción multiplicativa de Learning Rate.

¿Qué es Linear Decay?

Es una transición lineal entre tasas.

¿Qué es Cosine Annealing?

Es una programación basada en una función coseno.

¿Qué es Cosine Annealing Warm Restarts?

Es una estrategia que reinicia ciclos de Learning Rate.

¿Warm Restarts reinicia los pesos?

No en su funcionamiento convencional.

¿Qué es Warmup?

Es una etapa inicial de incremento progresivo de Learning Rate.

¿Por qué utilizar Warmup?

Puede ayudar a controlar las primeras actualizaciones en determinados entrenamientos.

¿Qué es Warmup + Cosine Decay?

Es una combinación de aumento inicial y descenso posterior por coseno.

¿Qué es ReduceLROnPlateau?

Es un scheduler que reduce la tasa cuando una métrica deja de mejorar.

¿Qué significa factor en ReduceLROnPlateau?

Es el multiplicador de reducción.

¿Qué significa patience?

Es la tolerancia a periodos sin mejora.

¿Qué es min_lr?

Es la tasa mínima permitida.

¿Qué es cooldown?

Es un intervalo que modifica la frecuencia de nuevas reducciones después de una reducción previa.

¿Qué es Cyclical Learning Rate?

Es una política donde la tasa varía entre límites a lo largo de ciclos.

¿Qué es One-Cycle Policy?

Es una política que aumenta y después reduce Learning Rate dentro de un ciclo.

¿Qué es pct_start?

Es la fracción inicial dedicada a aumentar la tasa en OneCycleLR.

¿OneCycleLR cambia Momentum?

Puede hacerlo según el optimizador y la configuración.

¿OneCycleLR se actualiza por época?

No en el uso habitual de PyTorch; se actualiza por batch después de un paso efectivo.

¿Qué es T_max?

Es la duración configurada del programa de CosineAnnealingLR.

¿Qué es eta_min?

Es la tasa mínima de Cosine Annealing.

¿Qué diferencia existe entre scheduler por época y por paso?

El primero avanza una vez por época; el segundo avanza después de actualizaciones del optimizador.

¿Se puede utilizar Learning Rate Scheduling con SGD?

Sí.

¿Se puede utilizar con Adam?

Sí.

¿Se puede utilizar con AdamW?

Sí.

¿Se puede utilizar con RMSprop?

Sí.

¿Se puede utilizar con AdaGrad?

Sí, aunque debe considerarse su adaptación acumulativa.

¿Learning Rate Scheduling evita Overfitting?

No automáticamente.

¿Learning Rate Scheduling puede producir Underfitting?

Sí, si reduce excesivamente las actualizaciones.

¿Se puede combinar con Dropout?

Sí.

¿Se puede combinar con Early Stopping?

Sí.

¿Qué diferencia existe entre ReduceLROnPlateau y Early Stopping?

Uno reduce la tasa y el otro detiene el entrenamiento.

¿Qué es Gradient Accumulation?

Es acumular gradientes de varios mini-batches antes de actualizar.

¿Por qué afecta al scheduler?

Porque cambia la cantidad de pasos efectivos del optimizador.

¿Se utiliza Learning Rate Scheduling en Transformers?

Sí.

¿Se utiliza en Fine-Tuning de LLM?

Sí.

¿Se utiliza con LoRA?

Sí.

¿PyTorch ofrece Learning Rate Schedulers?

Sí, mediante torch.optim.lr_scheduler.

¿Keras ofrece Learning Rate Schedules?

Sí, mediante objetos de schedule y callbacks.

¿Cómo guardar un scheduler en PyTorch?

Mediante su state_dict() junto con el estado del optimizador y del modelo.

¿Cuál es el mejor scheduler?

No existe una estrategia universalmente superior.

¿Cosine Annealing es siempre mejor que Step Decay?

No.

¿Qué métricas se utilizan para seleccionar schedulers?

Por ejemplo, Validation Loss, Macro-F1 y métricas de eficiencia.

¿Learning Rate Scheduling requiere GPU?

No.

¿Por qué importa para AI Visibility?

Porque puede mejorar el procedimiento de entrenamiento de clasificadores utilizados para analizar respuestas comerciales.

¿Aumenta directamente Recommendation Rate?

No.

¿Modifica directamente las respuestas de ChatGPT?

No cuando se utiliza en un sistema externo de análisis.

Conceptos relacionados

• Inteligencia Artificial: desarrollo de sistemas inteligentes.
• Machine Learning: aprendizaje a partir de datos.
• Deep Learning: entrenamiento de redes profundas.
• Redes Neuronales: modelos con parámetros entrenables.
• Aprendizaje Supervisado: entrenamiento con etiquetas.
• Aprendizaje Online: aprendizaje progresivo.
• Clasificación: predicción de categorías.
• Regresión: predicción numérica.
• Conjuntos de Entrenamiento, Validación y Prueba: evaluación independiente.
• Validación Cruzada: evaluación mediante particiones.
• Sobreajuste: adaptación excesiva.
• Subajuste: aprendizaje insuficiente.
• Regularización: control de complejidad.
• Ajuste de Hiperparámetros: selección de configuraciones.
• Función de Pérdida: cuantificación del error.
• Descenso del Gradiente: optimización mediante gradientes.
• Tasa de Aprendizaje: escala de actualizaciones.
• Retropropagación: cálculo de gradientes.
• SGD: descenso del gradiente estocástico.
• Momentum: acumulación histórica de gradientes.
• Adam: estimación adaptativa de momentos.
• AdamW: Adam con Weight Decay desacoplada.
• RMSprop: optimización adaptativa mediante gradientes cuadrados.
• AdaGrad: adaptación mediante acumuladores.
• Early Stopping: detención temprana.
• Learning Rate Scheduling: programación de tasa.
• Step Decay: reducción por intervalos.
• Exponential Decay: descenso exponencial.
• Cosine Annealing: descenso mediante coseno.
• Warmup: incremento inicial de tasa.
• Warm Restarts: reinicio de ciclos.
• ReduceLROnPlateau: reducción ante estancamiento.
• One-Cycle Policy: ciclo de aumento y descenso.
• Gradient Accumulation: acumulación de gradientes.
• Fine-Tuning: adaptación de modelos preentrenados.
• Visibilidad en Inteligencia Artificial: análisis de menciones, recomendaciones y citas.

Conclusión

La Programación de la Tasa de Aprendizaje (Learning Rate Scheduling) es una técnica fundamental para controlar el comportamiento de los optimizadores durante el entrenamiento.

Su principal función consiste en modificar Learning Rate a lo largo del proceso de aprendizaje.

Existen estrategias sencillas, como Step Decay y Exponential Decay, y otras más elaboradas, como Cosine Annealing, Warmup, Cyclical Learning Rates y One-Cycle Policy.

También existen estrategias basadas en métricas, como ReduceLROnPlateau.

Estas políticas permiten adaptar la magnitud de las actualizaciones a diferentes etapas del entrenamiento.

Sin embargo, no existe un scheduler universalmente óptimo.

Una programación demasiado agresiva puede reducir el aprendizaje antes de tiempo.

Una tasa excesiva puede producir inestabilidad.

Por eso, la selección debe considerar la arquitectura, el optimizador, los datos y el presupuesto de entrenamiento.

También es importante utilizar correctamente las unidades de programación.

Algunos schedulers se actualizan por época y otros después de cada paso efectivo del optimizador.

Esta distinción es especialmente importante cuando se utilizan Gradient Accumulation, Mixed Precision o entrenamientos con un número fijo de pasos.

En aplicaciones de AI Visibility, Learning Rate Scheduling puede ayudar a entrenar clasificadores neuronales utilizados para identificar menciones, recomendaciones y comparaciones.

Pero la calidad final depende igualmente de las etiquetas, los datos y la evaluación independiente.

La conclusión fundamental es que Learning Rate Scheduling controla cómo evoluciona la magnitud de las actualizaciones durante entrenamiento. Su eficacia depende de seleccionar una estrategia apropiada, sincronizarla con los pasos reales del optimizador y comprobar sus resultados mediante experimentos reproducibles.