Barridos de hiperparámetros

Trackio no incluye de forma intencional una API de barridos de primer nivel. Un barrido es un simple bucle de Python: una ejecución por configuración, agrupada de modo que el panel de control y las consultas puedan tratar el barrido como una unidad. Esto mantiene los barridos totalmente bajo tu control: cualquier estrategia de búsqueda que puedas escribir (o pedirle a un agente de código que escriba) funciona, sin necesidad de aprender nada nuevo.

Esta página reúne recetas para los casos más comunes.

El patrón

Cada receta a continuación es una variación de los mismos tres ingredientes:

• Una ejecución por configuración — llama a init() una vez por prueba.
• group — establécelo en un identificador de barrido para que todos los ensayos de un mismo barrido se mantengan juntos (consulta Agrupación de ejecuciones).
• config — registra los hiperparámetros para que los resultados sean comparables más adelante.

import trackio

def train(config: dict, group: str, name: str) -> float:
    trackio.init(project="my_project", name=name, group=group, config=config)

    final_loss = None
    for epoch in range(10):
        final_loss = ...  # your actual training step
        trackio.log({"loss": final_loss, "epoch": epoch})

    trackio.finish()
    return final_loss

Búsqueda en cuadrícula

Enumere el producto cartesiano completo del espacio de búsqueda con itertools.product:

import itertools

search_space = {
    "lr": [1e-2, 1e-3, 1e-4],
    "batch_size": [32, 128],
}

best = None
for values in itertools.product(*search_space.values()):
    config = dict(zip(search_space.keys(), values))
    name = "grid-" + "-".join(f"{k}={v}" for k, v in config.items())
    loss = train(config, group="grid-search", name=name)
    if best is None or loss < best[1]:
        best = (config, loss)

print(f"best config: {best[0]} (loss {best[1]:.3f})")

Búsqueda aleatoria

Muestrear configuraciones en lugar de enumerarlas: suele ser un mejor uso del mismo presupuesto cuando algunos hiperparámetros importan mucho más que otros. Fijar la semilla del generador para que el barrido sea reproducible:

import random

N_TRIALS = 20
rng = random.Random(42)

best = None
for trial in range(N_TRIALS):
    config = {
        "lr": 10 ** rng.uniform(-5, -1),
        "batch_size": rng.choice([16, 32, 64, 128, 256]),
    }
    loss = train(config, group="random-search", name=f"random-{trial}")
    if best is None or loss < best[1]:
        best = (config, loss)

Optimización bayesiana con Optuna

Para estrategias de búsqueda más inteligentes, utiliza una biblioteca dedicada y deja que Trackio se encargue del seguimiento. Con Optuna (pip install optuna), cada ensayo se convierte en una ejecución de Trackio:

import optuna

def objective(trial):
    config = {
        "lr": trial.suggest_float("lr", 1e-5, 1e-1, log=True),
        "batch_size": trial.suggest_categorical("batch_size", [16, 32, 64, 128]),
    }
    return train(config, group="optuna-sweep", name=f"optuna-{trial.number}")

study = optuna.create_study(direction="minimize")
study.optimize(objective, n_trials=20)

print("best:", study.best_params, study.best_value)

Ver los resultados del barrido

En el panel de control (trackio show), las ejecuciones que comparten un group se agrupan en la barra lateral, lo que permite activar o desactivar un barrido como una unidad y comparar sus ejecuciones en los mismos gráficos. Dado que cada ensayo registra sus hiperparámetros en config, los barridos también son una opción natural para comparar configuraciones de ejecución lado a lado.

Consultar la mejor configuración

Como todo está en SQLite, “¿qué configuración ganó?” es una consulta. El grupo de la ejecución se guarda dentro del JSON de la configuración bajo la clave _Group:

trackio query project --project "my_project" --sql "
SELECT m.run_name,
       json_extract(m.metrics, '$.loss') AS final_loss
FROM metrics m
JOIN configs c ON c.run_name = m.run_name
WHERE json_extract(c.config, '$._Group') = 'grid-search'
  AND m.id = (SELECT MAX(id) FROM metrics WHERE run_name = m.run_name)
ORDER BY final_loss ASC
LIMIT 5"

Agrega --json para obtener una salida legible por máquina. Consulta Storage Schema and Direct Queries para ver el esquema completo.

Ejecución de barridos con un agente de codificación

Los sweeps son una tarea natural para delegar: el bucle es mecánico y Trackio ofrece a los agentes acceso programático a los resultados (CLI con --json, la API de Python y SQL directo). Un prompt tan simple como:

Ejecuta una búsqueda aleatoria sobre lr (log-uniforme, 1e-5 a 1e-1) y batch_size (16–256) para mi script de entrenamiento. Crea una ejecución de Trackio por ensayo en el grupo “sweep-aug30”, 20 ensayos, luego consulta los resultados e informa las tres mejores configuraciones.

es suficiente para que un agente escriba el bucle, lo ejecute y lea los resultados. Consulta Ejecutar experimentos de ML con agentes para ver cómo estructurar el bucle de retroalimentación completo, incluidas las alertas y la supervisión.

Ejemplo ejecutable

Un script completo y autónomo con la cuadrícula y las recetas aleatorias se encuentra en examples/sweep-recipes.py.