En este tutorial, exploramos Hidraun entorno de mandato de configuración reformista desarrollado originalmente y de código destapado por Meta Research. Comenzamos definiendo configuraciones estructuradas utilizando clases de datos de Python, lo que nos permite dirigir los parámetros del prueba de una forma limpia, modular y reproducible. A medida que avanzamos en el tutorial, componemos configuraciones, aplicamos anulaciones de tiempo de ejecución y simulamos experimentos de ejecución múltiple para barridos de hiperparámetros. Mira el CÓDIGOS COMPLETOS aquí.
import subprocess
import sys
subprocess.check_call((sys.executable, "-m", "pip", "install", "-q", "hydra-core"))
import hydra
from hydra import compose, initialize_config_dir
from omegaconf import OmegaConf, DictConfig
from dataclasses import dataclass, field
from typing import List, Optional
import os
from pathlib import PathComenzamos instalando Hydra e importando todos los módulos esenciales necesarios para configuraciones estructuradas, composición dinámica y manejo de archivos. Esta configuración garantiza que nuestro entorno esté perspicaz para ejecutar el tutorial completo sin problemas en Google Colab. Mira el CÓDIGOS COMPLETOS aquí.
@dataclass
class OptimizerConfig:
_target_: str = "torch.optim.SGD"
lr: float = 0.01
@dataclass
class AdamConfig(OptimizerConfig):
_target_: str = "torch.optim.Adam"
lr: float = 0.001
betas: tuple = (0.9, 0.999)
weight_decay: float = 0.0
@dataclass
class SGDConfig(OptimizerConfig):
_target_: str = "torch.optim.SGD"
lr: float = 0.01
momentum: float = 0.9
nesterov: bool = True
@dataclass
class ModelConfig:
name: str = "resnet"
num_layers: int = 50
hidden_dim: int = 512
dropout: float = 0.1
@dataclass
class DataConfig:
dataset: str = "cifar10"
batch_size: int = 32
num_workers: int = 4
augmentation: bool = True
@dataclass
class TrainingConfig:
model: ModelConfig = field(default_factory=ModelConfig)
data: DataConfig = field(default_factory=DataConfig)
optimizer: OptimizerConfig = field(default_factory=AdamConfig)
epochs: int = 100
seed: int = 42
device: str = "cuda"
experiment_name: str = "exp_001"Definimos configuraciones limpias y de tipo seguro utilizando clases de datos de Python para el maniquí, los datos y la configuración del optimizador. Esta estructura nos permite ejecutar parámetros de experimentos complejos de forma modular y fácil, al tiempo que garantiza la coherencia entre ejecuciones. Mira el CÓDIGOS COMPLETOS aquí.
def setup_config_dir():
config_dir = Path("./hydra_configs")
config_dir.mkdir(exist_ok=True)
main_config = """
defaults:
- model: resnet
- data: cifar10
- optimizer: adam
- _self_
epochs: 100
seed: 42
device: cuda
experiment_name: exp_001
"""
(config_dir / "config.yaml").write_text(main_config)
model_dir = config_dir / "model"
model_dir.mkdir(exist_ok=True)
(model_dir / "resnet.yaml").write_text("""
name: resnet
num_layers: 50
hidden_dim: 512
dropout: 0.1
""")
(model_dir / "vit.yaml").write_text("""
name: vision_transformer
num_layers: 12
hidden_dim: 768
dropout: 0.1
patch_size: 16
""")
data_dir = config_dir / "data"
data_dir.mkdir(exist_ok=True)
(data_dir / "cifar10.yaml").write_text("""
dataset: cifar10
batch_size: 32
num_workers: 4
augmentation: true
""")
(data_dir / "imagenet.yaml").write_text("""
dataset: imagenet
batch_size: 128
num_workers: 8
augmentation: true
""")
opt_dir = config_dir / "optimizer"
opt_dir.mkdir(exist_ok=True)
(opt_dir / "adam.yaml").write_text("""
_target_: torch.optim.Adam
lr: 0.001
betas: (0.9, 0.999)
weight_decay: 0.0
""")
(opt_dir / "sgd.yaml").write_text("""
_target_: torch.optim.SGD
lr: 0.01
momentum: 0.9
nesterov: true
""")
return str(config_dir.absolute())Creamos mediante programación un directorio que contiene archivos de configuración YAML para modelos, conjuntos de datos y optimizadores. Este enfoque nos permite demostrar cómo Hydra compone automáticamente configuraciones a partir de diferentes archivos, manteniendo así la flexibilidad y claridad en los experimentos. Mira el CÓDIGOS COMPLETOS aquí.
@hydra.main(version_base=None, config_path="hydra_configs", config_name="config")
def train(cfg: DictConfig) -> float:
print("=" * 80)
print("CONFIGURATION")
print("=" * 80)
print(OmegaConf.to_yaml(cfg))
print("n" + "=" * 80)
print("ACCESSING CONFIGURATION VALUES")
print("=" * 80)
print(f"Model: {cfg.model.name}")
print(f"Dataset: {cfg.data.dataset}")
print(f"Batch Size: {cfg.data.batch_size}")
print(f"Optimizer LR: {cfg.optimizer.lr}")
print(f"Epochs: {cfg.epochs}")
best_acc = 0.0
for epoch in range(min(cfg.epochs, 3)):
acc = 0.5 + (epoch * 0.1) + (cfg.optimizer.lr * 10)
best_acc = max(best_acc, acc)
print(f"Epoch {epoch+1}/{cfg.epochs}: Accuracy = {acc:.4f}")
return best_accImplementamos una función de capacitación que aprovecha el sistema de configuración de Hydra para imprimir, conseguir y usar títulos de configuración anidados. Al fingir un ciclo de entrenamiento simple, mostramos cómo Hydra integra limpiamente el control del prueba en flujos de trabajo reales. Mira el CÓDIGOS COMPLETOS aquí.
def demo_basic_usage():
print("n" + "🚀 DEMO 1: Basic Configurationn")
config_dir = setup_config_dir()
with initialize_config_dir(version_base=None, config_dir=config_dir):
cfg = compose(config_name="config")
print(OmegaConf.to_yaml(cfg))
def demo_config_override():
print("n" + "🚀 DEMO 2: Configuration Overridesn")
config_dir = setup_config_dir()
with initialize_config_dir(version_base=None, config_dir=config_dir):
cfg = compose(
config_name="config",
overrides=(
"model=vit",
"data=imagenet",
"optimizer=sgd",
"optimizer.lr=0.1",
"epochs=50"
)
)
print(OmegaConf.to_yaml(cfg))
def demo_structured_config():
print("n" + "🚀 DEMO 3: Structured Config Validationn")
from hydra.core.config_store import ConfigStore
cs = ConfigStore.instance()
cs.store(name="training_config", node=TrainingConfig)
with initialize_config_dir(version_base=None, config_dir=setup_config_dir()):
cfg = compose(config_name="config")
print(f"Config type: {type(cfg)}")
print(f"Epochs (validated as int): {cfg.epochs}")
def demo_multirun_simulation():
print("n" + "🚀 DEMO 4: Multirun Simulationn")
config_dir = setup_config_dir()
experiments = (
("model=resnet", "optimizer=adam", "optimizer.lr=0.001"),
("model=resnet", "optimizer=sgd", "optimizer.lr=0.01"),
("model=vit", "optimizer=adam", "optimizer.lr=0.0001"),
)
results = {}
for i, overrides in enumerate(experiments):
print(f"n--- Experiment {i+1} ---")
with initialize_config_dir(version_base=None, config_dir=config_dir):
cfg = compose(config_name="config", overrides=overrides)
print(f"Model: {cfg.model.name}, Optimizer: {cfg.optimizer._target_}")
print(f"Learning Rate: {cfg.optimizer.lr}")
results(f"exp_{i+1}") = cfg
return results
def demo_interpolation():
print("n" + "🚀 DEMO 5: Variable Interpolationn")
cfg = OmegaConf.create({
"model": {"name": "resnet", "layers": 50},
"experiment": "${model.name}_${model.layers}",
"output_dir": "/outputs/${experiment}",
"checkpoint": "${output_dir}/best.ckpt"
})
print(OmegaConf.to_yaml(cfg))
print(f"nResolved experiment name: {cfg.experiment}")
print(f"Resolved checkpoint path: {cfg.checkpoint}")Demostramos las capacidades avanzadas de Hydra, incluidas anulaciones de configuración, potencia de configuración estructurada, simulaciones de ejecución múltiple e interpolación de variables. Cada demostración muestra cómo Hydra acelera la velocidad de experimentación, agiliza la configuración manual y fomenta la reproducibilidad en la investigación. Mira el CÓDIGOS COMPLETOS aquí.
if __name__ == "__main__":
demo_basic_usage()
demo_config_override()
demo_structured_config()
demo_multirun_simulation()
demo_interpolation()
print("n" + "=" * 80)
print("Tutorial complete! Key takeaways:")
print("✓ Config composition with defaults")
print("✓ Runtime overrides via command line")
print("✓ Structured configs with type safety")
print("✓ Multirun for hyperparameter sweeps")
print("✓ Variable interpolation")
print("=" * 80)Ejecutamos todas las demostraciones en secuencia para observar a Hydra en hecho, desde cargar configuraciones hasta realizar ejecuciones múltiples. Al final, resumimos las conclusiones secreto, reforzando cómo Hydra permite una mandato de experimentos elegante y escalable.
En conclusión, entendemos cómo Hydra, iniciada por Meta Research, simplifica y mejoramiento la mandato de experimentos a través de su potente sistema de composición. Exploramos configuraciones estructuradas, interpolación y capacidades de ejecución múltiple que hacen que los flujos de trabajo de estudios involuntario a gran escalera sean más flexibles y fáciles de proseguir. Con este conocimiento, ahora está equipado para integrar Hydra en sus propios procesos de investigación o exposición, garantizando reproducibilidad, eficiencia y claridad en cada prueba que ejecute.
Mira el CÓDIGOS COMPLETOS aquí. No dudes en consultar nuestra Página de GitHub para tutoriales, códigos y cuadernos. Por otra parte, no dudes en seguirnos en Gorjeo y no olvides unirte a nuestro SubReddit de más de 100.000 ml y suscríbete a nuestro boletín. ¡Esperar! estas en telegrama? Ahora todavía puedes unirte a nosotros en Telegram.
Asif Razzaq es el director ejecutante de Marktechpost Media Inc.. Como patrón e ingeniero iluminado, Asif está comprometido a utilizar el potencial de la inteligencia fabricado para el admisiblemente social. Su esfuerzo más nuevo es el extensión de una plataforma de medios de inteligencia fabricado, Marktechpost, que se destaca por su cobertura en profundidad del estudios involuntario y las parte sobre estudios profundo que es técnicamente sólida y fácilmente comprensible para una amplia audiencia. La plataforma cuenta con más de 2 millones de visitas mensuales, lo que ilustra su popularidad entre el notorio.