from omegaconf import DictConfig, OmegaConf
import hydra
@hydra.main(version_base=None)
def my_app(cfg: DictConfig) -> None:
    print(OmegaConf.to_yaml(cfg))
if __name__ == "__main__":
    my_app()

{}

outputs/
├── yyyy-mm-dd/          # 按日期分組
│   └── hh-mm-ss/        # 按時(shí)間精確到秒
│       └── .hydra/      # 保存本次運(yùn)行的配置
│           ├── config.yaml    # 完整的配置
│           ├── hydra.yaml     # Hydra 自身的配置
│           └── overrides.yaml # 命令行覆蓋的參數(shù)
│       └── my_app.log   # 日志文件（如果配置了日志）
│       └── 其他輸出文件     # 你的程序生成的文件

# 不支持直接在 +key=value 語法中傳入非 ASCII 字符
python my_app.py +name="zhangsan" +age=25

name: zhangsan
age: 25

python my_app.py --config-path=. --config-name=config

from omegaconf import DictConfig, OmegaConf
import hydra
@hydra.main(version_base=None, config_path=".", config_name="config")
def my_app(cfg):
    print(OmegaConf.to_yaml(cfg))
if __name__ == "__main__":
    my_app()

python my_app.py name="lisi"

python my_app.py ++name="wangwu" ++password=1234

from omegaconf import DictConfig, OmegaConf
import hydra
@hydra.main(version_base=None, config_path=".", config_name="config")
def my_app(cfg: DictConfig):
    # 屬性式訪問配置值
    assert cfg.name == "張三"
    # 字典式訪問配置值
    assert cfg["age"] == 25
    # 修改已有配置值
    cfg.name = "李四"          
    cfg["age"] = 30            
    assert cfg.name == "李四"
    assert cfg["age"] == 30
    # 訪問缺失值會(huì)拋出異常
    try:
        cfg.birth_year
    except Exception as e:
        print("error !!")
        print(e)
if __name__ == "__main__":
    my_app()

from omegaconf import DictConfig, OmegaConf
import hydra
import os
@hydra.main(version_base=None, config_path=".", config_name="config")
def my_app(cfg: DictConfig):
    # 關(guān)閉struct模式，允許新增配置鍵
    OmegaConf.set_struct(cfg, False)
    # 同一級(jí)新增配置
    cfg.birth_year = 1995      
    cfg["hobby"] = ["籃球", "編程"]
    # 無法直接給不存在的嵌套層級(jí)鏈?zhǔn)劫x值
    # cfg.address.city = "北京"          
    # 需要先創(chuàng)建嵌套層級(jí)，再賦值子鍵
    cfg.address = OmegaConf.create({})  # 顯式創(chuàng)建空的嵌套
    cfg.address.city = "北京"         
    cfg.address["district"] = "朝陽區(qū)"
    # 驗(yàn)證寫入結(jié)果
    assert cfg.birth_year == 1995  
    assert cfg.address.district == "朝陽區(qū)"
    print("配置寫入驗(yàn)證通過！")
if __name__ == "__main__":
    my_app()

├─ conf
│  └─ model
│      ├─ cnn.yaml
│      └─ transformer.yaml
└── my_app.py

backbone: resnet50
learning_rate: 0.001
batch_size: 32
epochs: 20
dropout: 0.2

backbone: vit_base
learning_rate: 0.0001
batch_size: 16
epochs: 30
attention_heads: 12

from omegaconf import DictConfig, OmegaConf
import hydra
@hydra.main(version_base=None, config_path="conf", config_name="model/cnn")
def my_app(cfg: DictConfig) -> None:
    print(OmegaConf.to_yaml(cfg))
if __name__ == "__main__":
    my_app()

python my_app.py +model=transformer

python my_app.py +model=transformer model.epochs=40

defaults:
  - model: cnn

from omegaconf import DictConfig, OmegaConf
import hydra
@hydra.main(version_base=None, config_path="conf", config_name="config")
def my_app(cfg: DictConfig) -> None:
    print(OmegaConf.to_yaml(cfg))
if __name__ == "__main__":
    my_app()

defaults:
  - model: 
    - cnn
    - transformer

name: CIFAR-10
path: ./data/cifar10
num_classes: 10
learning_rate: 0.0001
augmentation: true  # 是否開啟數(shù)據(jù)增強(qiáng)

defaults:
  - model: cnn
  - dataset: cifar10 

model:
  # 此處為conf/model/cnn.yaml中的配置內(nèi)容
dataset:
  # 此處為conf/dataset/cifar10.yaml中的配置內(nèi)容

python my_app.py model=cnn model.epochs=30

python my_app.py ~model

defaults:
  - model: cnn
  - dataset: cifar10 
  - _self_
dataset: 
  name: my_dataset
version: 1.0

defaults:
  - model: cnn
  - dataset: cifar10 

python my_app.py hydra.mode=MULTIRUN model=cnn,transformer dataset=cifar10

python my_app.py hydra.mode=MULTIRUN model=cnn,transformer dataset=cifar10
# 本地啟動(dòng)2個(gè)任務(wù)
#0 : model=cnn dataset=cifar10
#1 : model=transformer dataset=cifar10

python my_app.py --multirun model=cnn,transformer dataset=cifar10
# 或
python my_app.py -m model=cnn,transformer dataset=cifar10

defaults:
  - model: cnn
  - dataset: cifar10 
hydra:
  mode: MULTIRUN # 設(shè)置運(yùn)行模式
  sweeper:
    params:
      dataset: cifar10
      model: transformer, cnn

$ python my_app.py
# 本地啟動(dòng)2個(gè)任務(wù)
#0 : model=transformer dataset=cifar10
#1 : model=cnn dataset=cifar10

from omegaconf import DictConfig, OmegaConf
import hydra
import os
@hydra.main(version_base=None, config_path="conf", config_name="config")
def my_app(_cfg: DictConfig) -> None:
    print(f"工作目錄：{os.getcwd()}")
    print(f"輸出目錄：{hydra.core.hydra_config.HydraConfig.get().runtime.output_dir}")
if __name__ == "__main__":
    my_app()

python my_app.py hydra.job.chdir=True

# hydra_log_demo.py
import logging
from omegaconf import DictConfig
import hydra
# 為本文件創(chuàng)建日志器
log = logging.getLogger(__name__)
@hydra.main(version_base=None)
def my_app(_cfg: DictConfig) -> None:
    log.info("Info 級(jí)別日志消息")
    log.debug("Debug 級(jí)別日志消息")
if __name__ == "__main__":
    my_app()

python hydra_log_demo.py hydra.verbose=true

python hydra_log_demo.py hydra.verbose="[__main__,my_custom_logger]"

import logging
logging.getLogger(NAME).setLevel(logging.DEBUG)

python my_app.py hydra/job_logging=None hydra/hydra_logging=None

$ python my_app.py --cfg job

python my_app.py --cfg hydra --package hydra.job

class ConfigStore(metaclass=Singleton):
    def store(
        self,
        name: str,
        node: Any,
        group: Optional[str] = None,
        package: Optional[str] = "_group_",
        provider: Optional[str] = None,
    ) -> None:
        """
        將配置節(jié)點(diǎn)存儲(chǔ)至配置倉庫中
        :param name: 配置名稱
        :param node: 配置節(jié)點(diǎn)，支持 DictConfig、ListConfig、
            結(jié)構(gòu)化配置（Structured configs），甚至普通的 dict 和 list 類型
        :param group: 配置分組，子分組分隔符為 '/'，
            例如 hydra/launcher
        :param package: 配置節(jié)點(diǎn)的父級(jí)層級(jí)結(jié)構(gòu)。
            子節(jié)點(diǎn)分隔符為 '.'，例如 foo.bar.baz
        :param provider: 提供該配置的模塊/應(yīng)用名稱，
            有助于調(diào)試排查問題。
        """
    ...

from omegaconf import DictConfig, OmegaConf
import hydra
@hydra.main(version_base=None, config_path="conf", config_name="model/cnn")
def my_app(cfg: DictConfig) -> None:
    print(OmegaConf.to_yaml(cfg))
if __name__ == "__main__":
    my_app()

├─ conf
│  └─ model
│      └─ cnn.yaml
└── my_app.py

backbone: resnet50
learning_rate: 0.001
batch_size: 32
epochs: 20
dropout: 0.2

from dataclasses import dataclass
import hydra
from omegaconf import DictConfig, OmegaConf
from hydra.core.config_store import ConfigStore
@dataclass
class TransformerConfig:
    optimizer: str = "sgd"
    lr: float = 0.0005
    hidden_dim: int = 256
cs = ConfigStore.instance()
# 將名為transformer的配置類注冊(cè)至model配置分組
# 注意出現(xiàn)實(shí)體文件會(huì)報(bào)錯(cuò)
cs.store(name="transformer", group="model", node=TransformerConfig)
@hydra.main(version_base=None, config_path="conf")
def my_app(cfg: DictConfig) -> None:
    print(OmegaConf.to_yaml(cfg))
if __name__ == "__main__":
    my_app()

python my_app.py +model=cnn

python my_app.py +model=transformer

from dataclasses import dataclass
import hydra
from omegaconf import DictConfig, OmegaConf
from hydra.core.config_store import ConfigStore
@dataclass
class TransformerConfig:
    optimizer: str = "sgd"
    lr: float = 0.0005
    hidden_dim: int = 256
cs = ConfigStore.instance()
# 直接使用類類型
cs.store(name="config1", node=TransformerConfig)
# 使用類實(shí)例（覆蓋部分默認(rèn)值）
cs.store(name="config2", node=TransformerConfig(optimizer="rmsprop", lr=0.002))
# 使用字典（會(huì)失去運(yùn)行時(shí)類型安全保障）
cs.store(name="config3", node={"optimizer": "adam", "lr": 0.003, "hidden_dim": 256})
# 3. Hydra主函數(shù)：加載并打印配置
@hydra.main(version_base=None, config_name="config1")  # 默認(rèn)加載config1
def main(cfg: DictConfig) -> None:
    print("當(dāng)前加載的配置內(nèi)容：")
    print(cfg)  
if __name__ == "__main__":
    main()

# 導(dǎo)入必要的庫
from dataclasses import dataclass 
from typing import Any           
import hydra                   
from hydra.core.config_store import ConfigStore 
from omegaconf import OmegaConf  
# 1. 定義CNN模型的配置
@dataclass  # 裝飾器：將普通類轉(zhuǎn)為結(jié)構(gòu)化配置類（自動(dòng)生成初始化、比較等方法）
class CNNConfig:
    """CNN模型的訓(xùn)練配置（包含該模型特有的所有參數(shù)）"""
    model_type: str = "cnn"      
    batch_size: int = 32          
    learning_rate: float = 0.001  
# 2. 定義Transformer模型的配置
@dataclass
class TransformerConfig:
    """Transformer模型的訓(xùn)練配置（包含該模型特有的所有參數(shù)）"""
    model_type: str = "transformer" 
    batch_size: int = 16            
    learning_rate: float = 0.0001  
    num_heads: int = 8         
@dataclass
class Config:
    """整個(gè)訓(xùn)練程序的主配置類"""
    # model字段：用于接收配置組中選擇的模型配置（暫時(shí)標(biāo)注為Any類型）
    model: Any
# 1. 獲取配置存儲(chǔ)庫的單例實(shí)例（整個(gè)程序只有一個(gè)ConfigStore）
cs = ConfigStore.instance()
# 2. 注冊(cè)主配置（名稱為"config"，對(duì)應(yīng)后續(xù)hydra.main的config_name）
cs.store(name="config", node=Config)
# 3. 注冊(cè)配置組：組名是"model"，包含兩個(gè)選項(xiàng)：
cs.store(group="model", name="cnn", node=CNNConfig)
cs.store(group="model", name="transformer", node=TransformerConfig)
# hydra.main裝飾器：標(biāo)記程序入口，指定配置名稱為"config"
@hydra.main(version_base=None, config_name="config")
def train_model(cfg: Config) -> None:
    """深度學(xué)習(xí)模型訓(xùn)練的主函數(shù)"""
    print("===== 當(dāng)前使用的訓(xùn)練配置 =====")
    print(OmegaConf.to_yaml(cfg))
# 程序啟動(dòng)入口
if __name__ == "__main__":
    train_model()

model: ???

python my_app.py +model=cnn

from dataclasses import dataclass
from typing import Any
import hydra
from omegaconf import MISSING  # 標(biāo)記字段“無默認(rèn)值”
from hydra.core.config_store import ConfigStore 
from omegaconf import OmegaConf  
@dataclass
class BaseModelConfig:
    """所有深度學(xué)習(xí)模型的基礎(chǔ)配置（抽離公共字段）"""
    model_type: str = MISSING       # 模型類型：無默認(rèn)值（必須由子類指定）
    batch_size: int = 32            # 公共字段：默認(rèn)批次大?。ㄗ宇惪芍貙懀?
    learning_rate: float = 0.001    # 公共字段：默認(rèn)學(xué)習(xí)率（子類可重寫）
# 1. 定義CNN模型的配置
@dataclass  # 裝飾器：將普通類轉(zhuǎn)為結(jié)構(gòu)化配置類（自動(dòng)生成初始化、比較等方法）
class CNNConfig(BaseModelConfig):
    """CNN模型的訓(xùn)練配置（包含該模型特有的所有參數(shù)）"""
    model_type: str = "cnn"      
    batch_size: int = 32          
    learning_rate: float = 0.001  
# 2. 定義Transformer模型的配置
@dataclass
class TransformerConfig(BaseModelConfig):
    """Transformer模型的訓(xùn)練配置（包含該模型特有的所有參數(shù)）"""
    model_type: str = "transformer" 
    batch_size: int = 16            
    learning_rate: float = 0.0001   
    num_heads: int = 8         
@dataclass
class Config:
    """整個(gè)訓(xùn)練程序的主配置類"""
    # 不再是Any，而是BaseModelConfig
    model: BaseModelConfig
# 1. 獲取配置存儲(chǔ)庫的單例實(shí)例（整個(gè)程序只有一個(gè)ConfigStore）
cs = ConfigStore.instance()
# 2. 注冊(cè)主配置（名稱為"config"，對(duì)應(yīng)后續(xù)hydra.main的config_name）
cs.store(name="config", node=Config)
# 3. 注冊(cè)配置組：組名是"model"，包含兩個(gè)選項(xiàng)：
cs.store(group="model", name="cnn", node=CNNConfig)
cs.store(group="model", name="transformer", node=TransformerConfig)
# hydra.main裝飾器：標(biāo)記程序入口，指定配置名稱為"config"
@hydra.main(version_base=None, config_name="config")
def train_model(cfg: Config) -> None:
    """深度學(xué)習(xí)模型訓(xùn)練的主函數(shù)"""
    print("===== 當(dāng)前使用的訓(xùn)練配置 =====")
    print(OmegaConf.to_yaml(cfg))
# 程序啟動(dòng)入口
if __name__ == "__main__":
    train_model()

from dataclasses import dataclass, field
from typing import Any, List       
# 定義默認(rèn)配置列表：從配置組"model"中加載名為"cnn"的配置
defaults = [
    {"model": "cnn"}
    # 設(shè)為 MISSING，則可強(qiáng)制用戶在命令行中指定該參數(shù)的值。
    # {"model": MISSING}
]
@dataclass
class Config:
    """整個(gè)訓(xùn)練程序的主配置類"""
    # 受@dataclass限制，此處需通過field定義默認(rèn)配置列表（默認(rèn)加載cnn配置）
    defaults: List[Any] = field(default_factory=lambda: defaults)
    # Hydra會(huì)根據(jù)默認(rèn)配置列表自動(dòng)填充該字段，類型為BaseModelConfig
    model: BaseModelConfig = MISSING

python my_app.py model=transformer

conf/
├── config.yaml          # 主配置（包含訓(xùn)練、模型、數(shù)據(jù)等）
└── model                # 模型配置組
    ├── resnet.yaml      # ResNet模型配置
    └── transformer.yaml # Transformer模型配置

defaults:
  - base_config          # 繼承基礎(chǔ)配置Schema
  - model: resnet        # 默認(rèn)使用ResNet模型配置
  - _self_               # 自身配置覆蓋默認(rèn)值
# 自定義訓(xùn)練參數(shù)
train:
  batch_size: 32
  lr: 0.001
debug: true

defaults:
  - base_resnet  # 繼承ResNet基礎(chǔ)Schema
# ResNet專屬參數(shù)
layers: 50
pretrained: true
num_classes: 1000

defaults:
  - base_transformer  # 繼承Transformer基礎(chǔ)Schema
# Transformer專屬參數(shù)
num_heads: 8
num_layers: 6
hidden_dim: 512
max_seq_len: 512

from dataclasses import dataclass
from omegaconf import OmegaConf, MISSING
import hydra
from hydra.core.config_store import ConfigStore
# -------------------------- 基礎(chǔ)Schema定義 --------------------------
@dataclass
class BaseModelConfig:
    """所有模型的基礎(chǔ)配置Schema"""
    model_type: str = MISSING  # 必選字段，無默認(rèn)值
    device: str = "cuda"       # 可選字段，默認(rèn)值cuda
    dropout: float = MISSING   # 必選字段，無默認(rèn)值
@dataclass
class ResNetConfig(BaseModelConfig):
    """ResNet模型專屬Schema（繼承基礎(chǔ)模型配置）"""
    model_type: str = "resnet"  # 固定值，標(biāo)識(shí)模型類型
    dropout: float = 0.1        # 覆蓋默認(rèn)值
    layers: int = MISSING       # ResNet專屬必選字段
    pretrained: bool = MISSING
    num_classes: int = MISSING
@dataclass
class TransformerConfig(BaseModelConfig):
    """Transformer模型專屬Schema（繼承基礎(chǔ)模型配置）"""
    model_type: str = "transformer"  # 固定值
    dropout: float = 0.1             # 覆蓋默認(rèn)值
    num_heads: int = MISSING         # Transformer專屬必選字段
    num_layers: int = MISSING
    hidden_dim: int = MISSING
    max_seq_len: int = MISSING
@dataclass
class TrainConfig:
    """訓(xùn)練配置Schema"""
    batch_size: int = MISSING
    lr: float = MISSING
    epochs: int = 10  # 默認(rèn)訓(xùn)練10輪
@dataclass
class Config:
    """整體配置Schema"""
    model: BaseModelConfig = MISSING  # 模型配置（必選）
    train: TrainConfig = MISSING     # 訓(xùn)練配置（必選）
    debug: bool = False              # 調(diào)試模式（可選）
# -------------------------- 注冊(cè)Schema到配置倉庫 --------------------------
cs = ConfigStore.instance()
cs.store(name="base_config", node=Config)  # 注冊(cè)主配置Schema
cs.store(group="model", name="base_resnet", node=ResNetConfig)  # 注冊(cè)ResNet Schema
cs.store(group="model", name="base_transformer", node=TransformerConfig)  # 注冊(cè)Transformer Schema
# -------------------------- 主函數(shù) --------------------------
@hydra.main(version_base=None, config_path="conf", config_name="config")
def train_app(cfg: Config) -> None:
    """深度學(xué)習(xí)訓(xùn)練入口，打印最終配置"""
    print("最終訓(xùn)練配置：")
    print(OmegaConf.to_yaml(cfg))
if __name__ == "__main__":
    train_app()

# 正常運(yùn)行（使用默認(rèn)ResNet配置）
python my_app.py
# 模擬配置錯(cuò)誤（layers字段應(yīng)為int類型，傳入字符串觸發(fā)校驗(yàn)失敗）
python my_app.py model.layers='attention' 

# 項(xiàng)目整體目錄
├── my_app.py               # 主程序
├── optimizer_lib.py        # 獨(dú)立的優(yōu)化器Schema庫
└── conf/
    ├── config.yaml         # 主配置
    └── optimizer/          # 本地優(yōu)化器配置組
        ├── sgd.yaml        
        └── adam.yaml       

from dataclasses import dataclass
from omegaconf import MISSING
from hydra.core.config_store import ConfigStore
# -------------------------- 優(yōu)化器基礎(chǔ)Schema --------------------------
@dataclass
class BaseOptimizerConfig:
    """所有優(yōu)化器的基礎(chǔ)Schema（獨(dú)立庫定義）"""
    opt_type: str = MISSING    # 必選字段：優(yōu)化器類型
    lr: float = MISSING        # 必選字段：學(xué)習(xí)率
    weight_decay: float = 0.0  # 可選字段：權(quán)重衰減，默認(rèn)0
# -------------------------- 具體優(yōu)化器Schema --------------------------
@dataclass
class SGDConfig(BaseOptimizerConfig):
    """SGD優(yōu)化器專屬Schema"""
    opt_type: str = "sgd"      # 固定標(biāo)識(shí)
    momentum: float = MISSING  # SGD專屬必選字段
    nesterov: bool = False     # 可選字段：是否使用Nesterov動(dòng)量
@dataclass
class AdamConfig(BaseOptimizerConfig):
    """Adam優(yōu)化器專屬Schema"""
    opt_type: str = "adam"     # 固定標(biāo)識(shí)
    betas: tuple[float, float] = (0.9, 0.999)  # 可選字段：beta參數(shù)
    eps: float = MISSING                       # Adam專屬必選字段
# -------------------------- 注冊(cè)跨配置組的Schema --------------------------
def register_optimizer_configs() -> None:
    cs = ConfigStore.instance()
    # 注冊(cè)到獨(dú)立分組：optimizer_lib/optimizer
    cs.store(
        group="optimizer_lib/optimizer",
        name="sgd",
        node=SGDConfig
    )
    cs.store(
        group="optimizer_lib/optimizer",
        name="adam",
        node=AdamConfig
    )

from dataclasses import dataclass
from omegaconf import MISSING, OmegaConf
import hydra
from hydra.core.config_store import ConfigStore
import optimizer_lib  # 導(dǎo)入獨(dú)立的優(yōu)化器庫
# -------------------------- 整體配置Schema --------------------------
@dataclass
class TrainConfig:
    """訓(xùn)練配置Schema"""
    batch_size: int = 32
    epochs: int = 10
@dataclass
class Config:
    """主配置Schema"""
    optimizer: optimizer_lib.BaseOptimizerConfig = MISSING  # 引用獨(dú)立庫的Schema
    train: TrainConfig = MISSING
    debug: bool = False
# -------------------------- 注冊(cè)本地Schema并加載跨組Schema --------------------------
cs = ConfigStore.instance()
cs.store(name="base_config", node=Config)  # 注冊(cè)主配置Schema
optimizer_lib.register_optimizer_configs()  # 注冊(cè)跨配置組的優(yōu)化器Schema
# -------------------------- 主函數(shù) --------------------------
@hydra.main(version_base=None, config_path="conf", config_name="config")
def train_app(cfg: Config) -> None:
    """訓(xùn)練入口，打印最終配置并觸發(fā)Schema校驗(yàn)"""
    print("最終訓(xùn)練配置（含跨組優(yōu)化器配置）：")
    print(OmegaConf.to_yaml(cfg))
if __name__ == "__main__":
    train_app()

defaults:
  - /optimizer_lib/optimizer/sgd@_here_  # 絕對(duì)路徑引用跨組Schema，@_here_統(tǒng)一包作用域
# SGD專屬配置（需符合SGDConfig的Schema規(guī)則）
lr: 0.01
momentum: 0.9
weight_decay: 0.0001

defaults:
  - /optimizer_lib/optimizer/adam@_here_  # 絕對(duì)路徑引用跨組Schema
  - _self_  # 自身配置覆蓋Schema默認(rèn)值（組合順序：Schema先加載，自身配置后覆蓋）
# Adam專屬配置（需符合AdamConfig的Schema規(guī)則）
lr: 0.001
betas: (0.9, 0.999)
eps: 1e-08
weight_decay: 0.0005

defaults:
  - base_config          # 主配置Schema
  - optimizer: sgd      # 默認(rèn)使用SGD優(yōu)化器配置
  - _self_
# 自定義訓(xùn)練參數(shù)
train:
  batch_size: 64
  epochs: 20
debug: true

# 正常運(yùn)行（SGD配置符合Schema規(guī)則）
python my_app.py
# 配置錯(cuò)誤（momentum應(yīng)為float，傳入字符串觸發(fā)校驗(yàn)失?。?
python my_app.py optimizer.momentum='high'
# 配置錯(cuò)誤（Adam必選字段eps缺失，啟動(dòng)時(shí)直接報(bào)錯(cuò)）
python my_app.py optimizer=adam optimizer.eps=none