Ajuste de hiperparámetros: métodos, buenas prácticas y ejemplos

La precisión de tu modelo no es mala porque elegiste el algoritmo equivocado: es porque nunca lo ajustaste.

Mucha gente entrena un modelo con la configuración por defecto, ve que la precisión se queda en torno al 80% y concluye que el algoritmo no sirve para su tarea. Pero el problema no es el algoritmo. Todo modelo de ML tiene parámetros que controlan cómo aprende, y esos parámetros se fijan antes de empezar el entrenamiento. Si los eliges bien, puedes sacar un 10-20% más de precisión con el mismo modelo y los mismos datos.

Estos parámetros se llaman hiperparámetros, y elegirlos bien marca la diferencia entre un modelo que cumple y uno que casi siempre acierta. El ajuste de hiperparámetros es el proceso de buscar la combinación que ofrece el mejor rendimiento.

En este artículo te explico qué es el ajuste de hiperparámetros, las estrategias de búsqueda que mejor funcionan, cómo evaluar resultados sin engañarte y cómo ejecutarlo todo en Python y R.

Si estás empezando con data science y machine learning, echa un vistazo al curso de Fundamentos de machine learning en Python antes de pasar a temas más avanzados.

¿Qué es el ajuste de hiperparámetros?

El ajuste de hiperparámetros es el proceso de encontrar la configuración con la que un modelo aprende mejor.

Todo modelo de ML maneja dos tipos de valores. Unos se aprenden de los datos durante el entrenamiento, como los pesos de una red neuronal o los puntos de corte en un árbol de decisión. Otros se fijan antes de empezar a entrenar, y esos son los hiperparámetros. Controlan cómo aprende el modelo: a qué ritmo, con qué profundidad, cuánto debe generalizar o memorizar.

Los valores por defecto existen para que el modelo funcione. No están pensados para darte el mejor modelo para tu conjunto de datos. Una tasa de aprendizaje por defecto que va bien en visión por computadora no rendirá igual en datos tabulares. Una profundidad de árbol por defecto que sirve para un dataset limpio sobreajustará en uno ruidoso. Ya te haces una idea.

El proceso de ajuste recorre distintas combinaciones de valores de hiperparámetros, entrena un modelo para cada una y se queda con el que mejor funciona en tus datos de validación. 

Lo que puedes ganar con esto suele ser mayor que cambiar a un algoritmo más sofisticado pero sin ajustar.

Hiperparámetros vs. parámetros del modelo

La diferencia está en quién los fija y cuándo.

Parámetros del modelo: los aprende el algoritmo durante el entrenamiento. Tú no los estableces. El proceso de entrenamiento los ajusta mirando los datos y minimizando una función de pérdida. Por ejemplo:

• Pesos y sesgos en una red neuronal
• Coeficientes en una regresión lineal
• Umbrales de split en un árbol de decisión
• Vectores de soporte en una SVM

Hiperparámetros: los eliges tú antes de entrenar. Controlan cómo funciona el proceso de aprendizaje, pero el algoritmo no los modificará. Si no los fijas, la librería usa sus valores por defecto. Por ejemplo:

• Tasa de aprendizaje en descenso de gradiente
• Número de árboles en un random forest
• Intensidad de regularización en regresión logística
• Tipo de kernel en una SVM

Aquí tienes una comparativa lado a lado:

Los parámetros del modelo responden a qué aprendió el modelo. Los hiperparámetros responden a cómo lo aprendió.

Cómo funciona el ajuste de hiperparámetros

El ajuste es un bucle.

Empiezas eligiendo los hiperparámetros que vas a explorar y definiendo un rango de valores para cada uno. Luego entrenas un modelo con una combinación, mides cómo rinde en validación y usas ese resultado para decidir qué probar después.

El bucle es así:

1. Selecciona los hiperparámetros a ajustar y define un rango de valores para cada uno.
2. Entrena el modelo con una combinación concreta de valores.
3. Evalúa el rendimiento en un conjunto de validación usando una métrica acorde a tu tarea.
4. Actualiza los hiperparámetros según lo aprendido: pasando a la siguiente combinación de una lista predefinida o usando el último resultado para guiar la siguiente elección.
5. Repite hasta que el rendimiento deje de mejorar o se agote tu presupuesto de cómputo.

La forma de actualizar entre iteraciones diferencia un método de búsqueda de otro. El ajuste manual se guía por la intuición. Grid search recorre una lista predefinida. Los métodos bayesianos construyen un modelo que estima qué combinaciones es más probable que funcionen.

Vamos con estos métodos.

Métodos de búsqueda de hiperparámetros

El método que elijas determina cuánto cómputo gastarás y qué probabilidad tienes de dar con buenos hiperparámetros.

Búsqueda manual

La búsqueda manual es el método más simple. Eliges una combinación de hiperparámetros, entrenas el modelo, miras el resultado y ajustas según lo observado.

Funciona cuando el modelo es pequeño, hay pocos hiperparámetros y tienes experiencia previa con el algoritmo. Si ya sabes que XGBoost suele ir bien con una tasa de aprendizaje en torno a 0.05 y profundidad 6, puedes empezar ahí y ajustar a partir de lo que veas.

La búsqueda manual deja de funcionar cuando el espacio crece. Tres hiperparámetros con cinco valores razonables cada uno ya son 125 combinaciones, y nadie ajusta 125 modelos a mano.

Grid search

Grid search prueba todas las combinaciones en una lista de valores predefinida.

Defines una rejilla —por ejemplo, tasas de aprendizaje [0.01, 0.05, 0.1] y profundidades de árbol [3, 5, 7]— y grid search entrena un modelo para cada una de las nueve combinaciones. Es exhaustivo y reproducible.

El problema es el coste computacional. 

Añadir un hiperparámetro más con cinco valores multiplica por cinco tus entrenamientos. Además, grid search malgasta esfuerzos en valores poco relevantes: si la profundidad apenas afecta a la puntuación, igual entrenará un modelo para cada profundidad listada.

Grid search es una buena opción por defecto para espacios pequeños con dos o tres hiperparámetros.

Búsqueda aleatoria

La búsqueda aleatoria toma combinaciones al azar de un rango en lugar de recorrer una rejilla fija.

Defines una distribución para cada hiperparámetro y la búsqueda aleatoria extrae combinaciones de esas distribuciones. Es más eficiente que grid search porque no desperdicia ejecuciones en valores que apenas influyen: si solo uno de cada tres hiperparámetros afecta al rendimiento, la búsqueda aleatoria sigue explorando el importante en muchos valores distintos.

Grid search frente a búsqueda aleatoria

La búsqueda aleatoria es la mejor opción por defecto cuando hay más de dos hiperparámetros.

Optimización bayesiana

La optimización bayesiana usa los resultados de pruebas previas para decidir qué probar a continuación.

Construye un modelo probabilístico que relaciona combinaciones de hiperparámetros con rendimiento y elige la siguiente combinación con mayor puntuación esperada o mayor incertidumbre. Es el equilibrio exploración-explotación: exploras regiones nuevas con potencial o explotas las que ya sabes que funcionan.

Los métodos bayesianos encuentran buenos hiperparámetros con muchas menos pruebas que la búsqueda aleatoria o por rejilla. A cambio, cada prueba tarda algo más porque el algoritmo debe ajustar su modelo interno antes de elegir el siguiente punto. Librerías como Optuna e Hyperopt lo hacen por ti.

Usa optimización bayesiana cuando entrenar es caro y solo puedes permitirte pocas ejecuciones.

Successive halving y Hyperband

Successive halving y Hyperband reducen el tiempo de cómputo parando pronto las ejecuciones malas.

Successive halving empieza muchas combinaciones con un pequeño presupuesto de entrenamiento, descarta la peor mitad, dobla el presupuesto de las supervivientes y repite. 

Hyperband envuelve successive halving corriéndolo varias veces con distintos repartos de presupuesto, así no tienes que adivinar la configuración inicial adecuada.

Ambos métodos son útiles cuando entrenar es lento y el espacio de búsqueda es grande. Funcionan mejor cuando el rendimiento temprano anticipa razonablemente el final, algo habitual en redes neuronales y gradient boosting.

Así se comparan los métodos:

Evaluación del rendimiento de los hiperparámetros

El ajuste no te llevará lejos si no eliges rangos de valores adecuados.

Si evalúas mal, elegirás mal los hiperparámetros. Hay cuatro cosas clave: cómo divides los datos, cómo mides el rendimiento, qué métrica optimizas y cómo mantienes limpio el conjunto de test.

Divisiones en entrenamiento, validación y test

Divide tus datos en tres partes antes de ajustar.

El conjunto de entrenamiento es del que aprende el modelo. El conjunto de validación sirve para puntuar cada combinación durante el ajuste. El conjunto de test lo usas una vez, al final, para medir cómo rinde el modelo final en datos no vistos.

Si ajustas contra el test, obtendrás una precisión que parece fantástica y un modelo que rinde peor en producción. Cada decisión que tomas usando el test filtra información de él al modelo.

Una división habitual es 60/20/20 para datasets medianos o 80/10/10 para más grandes.

Validación cruzada

La validación cruzada es mejor para puntuar hiperparámetros cuando tu conjunto de validación es pequeño.

Divides los datos de entrenamiento en k particiones —normalmente 5 o 10—. Para cada combinación, entrenas en k-1 particiones y validas en la restante, rotando. La puntuación final es la media de todas las particiones.

La validación cruzada te da una estimación más estable de cómo generaliza una combinación porque no dependes de una sola partición de validación con suerte o mala suerte. El coste es entrenar k modelos por combinación en lugar de uno.

Úsala cuando tu dataset sea lo bastante pequeño como para que una sola partición no sea fiable y cuando puedas asumir el coste extra.

Selección de métricas de evaluación

La métrica a optimizar debe reflejar lo que de verdad te importa.

La precisión está bien para clasificación equilibrada, pero no para problemas desbalanceados. Por ejemplo, un modelo de fraude que predice "no fraude" siempre puede lograr un 99% de precisión y fallar todos los casos. En clasificación desbalanceada usa precisión, recall, F1 o ROC-AUC. En regresión, usa RMSE, MAE o R cuadrado según te importen los outliers.

Elige una métrica principal antes de empezar a ajustar y cíñete a ella.

Evitar el leakage de datos

Hay leakage cuando información de tu validación o test se cuela en el entrenamiento.

Formas habituales de que ocurra:

• Escalar o normalizar todo el dataset antes de dividir, filtrando estadísticas de validación al entrenamiento
• Ingeniería de variables que usa el target de todo el conjunto
• Ajustar contra el test en lugar de contra un conjunto de validación
• Usar series temporales sin respetar el orden temporal en la división

Ajusta todo el preprocesado solo con el conjunto de entrenamiento y aplícalo luego a validación y test. En scikit-learn, para eso sirve Pipeline: combina preprocesado y modelado en un único objeto que respeta tus divisiones.

Implementación del ajuste de hiperparámetros

La mayoría de librerías de ML incluyen herramientas para la búsqueda y la validación cruzada, así que no tienes que implementarlo desde cero.

Ajuste de hiperparámetros en Python

Scikit-learn incluye dos clases que cubren la mayoría de casos: GridSearchCV para grid search y RandomizedSearchCV para búsqueda aleatoria. Ambas envuelven cualquier estimador de scikit-learn, ejecutan validación cruzada por combinación y te devuelven el mejor modelo.

GridSearchCV recibe un estimador, un diccionario de valores de hiperparámetros y el número de pliegues de la validación cruzada. Entrena un modelo por cada combinación y se queda con el de mejor puntuación.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=1000, random_state=42)

param_grid = {
    "n_estimators": [100, 200, 500],
    "max_depth": [5, 10, 20],
    "min_samples_leaf": [1, 5, 10],
}

grid = GridSearchCV(RandomForestClassifier(random_state=42), param_grid, cv=5)
grid.fit(X, y)

print(grid.best_params_)
print(grid.best_score_)

Resultados de GridSearchCV en Python

RandomizedSearchCV usa la misma interfaz pero muestrea de distribuciones en lugar de recorrer una lista fija. Así cubres un rango más amplio con un número fijo de pruebas.

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint

param_dist = {
    "n_estimators": randint(100, 500),
    "max_depth": randint(3, 20),
    "min_samples_leaf": randint(1, 10),
}

random_search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42),
    param_dist,
    n_iter=30,
    cv=5,
    random_state=42,
)
random_search.fit(X, y)

print(random_search.best_params_)

Resultados de RandomizedSearchCV en Python

Para optimización bayesiana, Optuna es la opción de referencia. Elige la siguiente combinación según resultados previos, por lo que converge más rápido que la búsqueda aleatoria cuando entrenar es costoso.

import optuna
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

def objective(trial):
    params = {
        "n_estimators": trial.suggest_int("n_estimators", 100, 500),
        "max_depth": trial.suggest_int("max_depth", 3, 20),
        "min_samples_leaf": trial.suggest_int("min_samples_leaf", 1, 10),
    }
    model = RandomForestClassifier(**params, random_state=42)
    return cross_val_score(model, X, y, cv=5).mean()

study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=30)

print(study.best_params)

Resultados de Optuna en Python

Los métodos trial.suggest_* definen el espacio de búsqueda y Optuna decide qué combinación probar a continuación según las puntuaciones vistas.

Ajuste de hiperparámetros en R

R tiene dos grandes opciones: caret y tidymodels. Ambas hacen lo mismo —definir una rejilla, ejecutar validación cruzada, devolver el mejor modelo—, pero tidymodels es el estándar moderno.

Con caret, pasas una rejilla de ajuste a la función train() y especificas el método de remuestreo.

library(caret)

data <- iris
ctrl <- trainControl(method = "cv", number = 5)

grid <- expand.grid(
  mtry = c(2, 3, 4)
)

model <- train(
  Species ~ .,
  data = data,
  method = "rf",
  trControl = ctrl,
  tuneGrid = grid
)

print(model$bestTune)

Resultados de Caret en R

tidymodels divide el flujo en pasos claros: especificación del modelo, receta de preprocesado y rejilla de ajuste. Es más verboso pero, en la práctica, más escalable.

library(tidymodels)

data <- iris
split <- initial_split(data, prop = 0.8)
train_data <- training(split)

rf_spec <- rand_forest(
  mtry = tune(),
  trees = tune(),
  min_n = tune()
) |>
  set_engine("ranger") |>
  set_mode("classification")

grid <- grid_regular(
  mtry(range = c(2, 4)),
  trees(range = c(100, 500)),
  min_n(range = c(1, 10)),
  levels = 3
)

folds <- vfold_cv(train_data, v = 5)

results <- tune_grid(
  rf_spec,
  Species ~ .,
  resamples = folds,
  grid = grid
)

show_best(results, metric = "accuracy")

Resultados de Tidymodels en R

El flujo es exactamente el mismo que en Python: defines qué buscar, cómo puntuarlo y dejas que la librería ejecute el bucle.

¿Qué hiperparámetros deberías ajustar?

No todos los hiperparámetros merecen la pena: normalmente unos pocos explican la mayor parte del rendimiento. Estos suelen ser los más relevantes por familia de modelos.

Árboles de decisión y random forests

Ajusta siempre estos tres:

• La profundidad máxima controla hasta dónde puede crecer cada árbol. Árboles poco profundos infraajustan; muy profundos sobreajustan. Suele ser lo primero a ajustar.
• El mínimo de muestras por hoja define cuántos puntos necesita un nodo hoja. Valores altos fuerzan a generalizar en lugar de memorizar filas individuales.
• El número de árboles en un random forest. Más árboles dan un modelo más estable, con rendimientos decrecientes a partir de unos cientos. Ajusta esto al final.

Modelos de gradient boosting

Gradient boosting (XGBoost, LightGBM, CatBoost) es más sensible a los hiperparámetros que los random forests. Fíjate en:

• La tasa de aprendizaje controla cuánto corrige cada árbol nuevo a los anteriores. Tazas más bajas son más precisas pero requieren más árboles. Es el hiperparámetro más importante.
• El número de estimadores es el número de rondas de boosting. Atalo a la tasa de aprendizaje: si bajas uno, sube el otro.
• La profundidad del árbol controla la complejidad de cada árbol. El boosting suele preferir árboles más poco profundos que los random forests, típicamente entre 3 y 8.

Máquinas de vectores de soporte (SVM)

En SVM, la elección de hiperparámetros importa mucho, quizá más que en otros modelos:

• C controla el equilibrio entre un margen amplio y clasificar bien los puntos de entrenamiento. C alto implica menos regularización.
• Gamma controla hasta dónde llega la influencia de un punto de entrenamiento. Gamma bajo, más lejos; gamma alto, más cerca.
• El kernel determina la forma de la frontera de decisión que la SVM puede aprender. Empieza con rbf para problemas no lineales y linear para datos dispersos y de alta dimensión.

Redes neuronales

Las redes neuronales tienen el mayor espacio de búsqueda. Empieza por estos:

• Tasa de aprendizaje: el hiperparámetro clave en deep learning. Si es demasiado alta, el entrenamiento diverge; si es muy baja, no converge. Prueba órdenes de magnitud como 1e-4, 1e-3, 1e-2.
• Tamaño de batch: afecta a la velocidad de entrenamiento y a la precisión final. Batches grandes entrenan más rápido por época, pero a menudo generalizan peor.
• Optimizador (Adam, SGD con momentum, AdamW) cambia cómo la red actualiza los pesos. Adam es un buen punto de partida.
• Épocas: cuántas veces ve el modelo todo el conjunto de entrenamiento. Usa early stopping en lugar de ajustar esto a mano.

Retos habituales en el ajuste de hiperparámetros

El ajuste es costoso, sobre todo si quieres probar múltiples valores por parámetro y hay muchos parámetros que ajustar. Estos son retos comunes:

Coste computacional: es la mayor limitación. Cada combinación implica entrenar un modelo completo, y la validación cruzada lo multiplica por el número de pliegues. Una rejilla de 100 combinaciones con CV de 5 pliegues son 500 ajustes. Si cada uno tarda 10 minutos, son más de tres días.

Espacios de búsqueda grandes: crecen multiplicativamente. Cinco hiperparámetros con cinco valores cada uno son 3.125 combinaciones. Aquí grid search deja de ser opción: toca búsqueda aleatoria o métodos bayesianos.

Rendimientos decrecientes: aparecen antes de lo que esperas. Las primeras ejecuciones suelen aportar la mayor mejora. Las siguientes 50 quizá te den un 1% extra. Llegado un punto, compensa más conseguir más datos o mejorar las variables.

Equilibrio precisión-tiempo: importa más en producción que en desarrollo. Un modelo que puntúa 0,5% más pero tarda el doble en entrenar quizá no compense si reentrenas a diario. Decide de antemano cuánto rendimiento vale cuánto cómputo.

Buenas prácticas para el ajuste de hiperparámetros

Buenos hábitos a seguir al ajustar los hiperparámetros de un modelo de machine learning:

• Ajusta primero los hiperparámetros más influyentes: Tasa de aprendizaje en boosting y redes. Profundidad máxima en árboles. C y gamma en SVM. Llévalos al rango adecuado antes de tocar el resto.
• Empieza con búsqueda aleatoria en espacios grandes: Grid search desperdicia cómputo en hiperparámetros poco relevantes. La búsqueda aleatoria cubre mejor el espacio y es la opción adecuada con más de dos o tres hiperparámetros.
• Usa validación cruzada: Una sola partición puede ser afortunada o desafortunada. Cinco pliegues te dan una estimación mucho más honesta de la generalización.
• Define rangos realistas: Si el rango de la tasa de aprendizaje es [0.001, 100] perderás tiempo en valores que nunca funcionan. Empieza con rangos razonables para tu algoritmo y ajústalos según lo observado.
• Registra tus experimentos: Anota los valores, la métrica y la semilla de cada ejecución. Herramientas como MLflow, Weights & Biases o incluso un CSV sirven. Sin esto, no podrás reproducir resultados.
• Marca un presupuesto de cómputo: Decide cuántas pruebas puedes permitirte antes de empezar, no después. Te obliga a elegir un método acorde y evita alargar el ajuste innecesariamente.

Errores comunes en el ajuste de hiperparámetros

La mayoría de fallos se deben a errores fáciles de evitar. Algunos ejemplos:

• Confundir hiperparámetros con parámetros del modelo. Los pesos y coeficientes se aprenden al entrenar. No los fijas a mano ni los ajustas. Si intentas ajustar algo que el algoritmo debería aprender, los has confundido.
• Ajustar contra el conjunto de test. Cada decisión basada en la puntuación de test filtra información al modelo. El número final será optimista y en producción rendirá peor. Usa validación separada o validación cruzada.
• Buscar rejillas innecesariamente grandes. Una rejilla con siete hiperparámetros y diez valores cada uno tiene diez millones de combinaciones. No vas a explorarlas. Redúcela eligiendo dos o tres hiperparámetros clave y rangos realistas.
• Optimizar la métrica equivocada. La precisión en un dataset desbalanceado te llevará a predecir siempre la clase mayoritaria. Elige una métrica que refleje lo que te importa y hazlo antes de ajustar.
• Cambiar demasiados hiperparámetros a la vez en ajuste manual. Si tocas a la vez la tasa de aprendizaje y el tamaño de batch, no sabrás qué ha causado el cambio. Ajusta de uno en uno cuando lo hagas a mano.

Ajuste de hiperparámetros vs. ingeniería de características

Ambos mejoran tu modelo, pero actúan en partes distintas del problema.

La ingeniería de características mejora los datos de entrada: creas nuevas variables, codificas categóricas, tratas faltantes y reduces ruido. Mejores variables proporcionan más señales útiles al modelo.

El ajuste de hiperparámetros mejora cómo aprende el modelo a partir de las variables que le das. Cambia el comportamiento del algoritmo sobre los datos, no los datos en sí.

Ambos son complementarios. La ingeniería de características suele dar las mayores ganancias al principio del proyecto, cuando los datos están crudos y el modelo se pierde señales evidentes. El ajuste de hiperparámetros aporta mejoras más pequeñas pero constantes cuando las variables ya son sólidas.

Si tu modelo se atasca y no sabes por dónde empezar, mira los errores. Si se pierde patrones obvios en los datos, es un problema de variables. Si sobreajusta o infraajusta, es un problema de ajuste.

Por qué importa el ajuste de hiperparámetros en machine learning

Ajustar es un paso estándar en cualquier flujo de ML.

A menudo aporta más que cambiar de algoritmo. Por ejemplo, un random forest bien ajustado suele superar a un modelo de gradient boosting mal ajustado en los mismos datos, aunque boosting sea más sofisticado. 

El ajuste también ayuda a generalizar. Hiperparámetros como la profundidad máxima o la tasa de dropout controlan directamente cuánto puede sobreajustar el modelo. Acertar con ellos marca la diferencia entre memorizar el entrenamiento o rendir bien en datos nuevos.

En producción, el ajuste convierte un prototipo en un sistema fiable. 

La configuración por defecto te pone en marcha, pero no te mantendrá competitivo frente a reentrenos y requisitos del negocio. Todo equipo serio de ML trata el ajuste como parte del proceso.

Conclusión

El ajuste de hiperparámetros es un bucle iterativo de búsqueda, evaluación y enfoque en lo que funciona para tus datos.

Los mejores resultados llegan combinando tres cosas: un método de búsqueda acorde a tu presupuesto de cómputo, una validación con una métrica relevante y un registro de experimentos que te permita revisar lo que probaste.

Empieza con búsqueda aleatoria o grid search. Pasa a optimización bayesiana cuando entrenar sea lo bastante caro como para que importe el número de pruebas. En cualquier caso, ajusta los hiperparámetros relevantes para tu modelo, mantén el test limpio y registra cada ejecución.

Si te planteas una carrera profesional en machine learning, apúntate a nuestro itinerario de Machine Learning Engineer para estar listo para 2026.