def test_searchpath_in_primary_config(
self,
init_configs: Any,
config_name: str,
overrides: List[str],
expected: Any,
) -> None:
cfg = compose(config_name=config_name, overrides=overrides)
assert cfg == expected
def __init__(self, **data: Any):
super().__init__(**data)
with initialize(config_path=self.config_path):
object.__setattr__(
self,
'configuration',
compose(self.config_filename)
)
logger.debug("Configuration: \n" + OmegaConf.to_yaml(self.configuration))
def test_initialize_config_module_ctx(
self, config_file: str, overrides: List[str], expected: Any,
) -> None:
with initialize_config_module(
config_module="examples.jupyter_notebooks.cloud_app.conf",
job_name="job_name",
):
ret = compose(config_file, overrides)
assert ret == expected
def test_strict_failure_call_is_strict(
self,
config_dir: str,
hydra_global_context: TGlobalHydraContext,
config_file: str,
overrides: List[str],
expected: Any,
) -> None:
# default strict false, but call is strict
with hydra_global_context(config_dir=config_dir, strict=False):
with pytest.raises(AttributeError):
compose(config_name=config_file, overrides=overrides, strict=True)
# default strict true, but call is false
with hydra_global_context(config_dir=config_dir, strict=True):
with does_not_raise():
compose(config_name=config_file, overrides=overrides, strict=False)
def test_initialize_with_module(hydra_restore_singletons: Any) -> None:
initialize_with_module(module="tests.test_apps.app_with_cfg_groups.my_app",
config_path="conf")
assert compose(config_name="config") == {
"optimizer": {
"type": "nesterov",
"lr": 0.001
}
}
def get_global_cfg():
"""
WARNING: does not work, hydra compose API seems to work only in Jupyter now
Use experimental Hydra compose API
"""
raise NotImplementedError
from hydra.experimental import initialize, compose
initialize(config_dir='../../conf', strict=True)
return compose('config.yaml')
def test_jobname_override_initialize_ctx(hydra_restore_singletons: Any,
job_name: Optional[str],
expected: str) -> None:
with initialize(
config_path="../examples/jupyter_notebooks/cloud_app/conf",
job_name=job_name,
):
ret = compose(return_hydra_config=True)
assert ret.hydra.job.name == expected
def test_initialize_config_module_ctx(hydra_restore_singletons: Any) -> None:
with initialize_config_module(
config_module="examples.jupyter_notebooks.cloud_app.conf"
):
ret = compose(return_hydra_config=True)
assert ret.hydra.job.name == "app"
with initialize_config_module(
config_module="examples.jupyter_notebooks.cloud_app.conf", job_name="test_job"
):
ret = compose(return_hydra_config=True)
assert ret.hydra.job.name == "test_job"
with initialize_config_module(
config_module="examples.jupyter_notebooks.cloud_app.conf", job_name="test_job"
):
ret = compose(return_hydra_config=True)
assert ret.hydra.job.name == "test_job"
def test_dataloader_drops_last(tmpdir) -> None:
config_path = "./configs/classification"
with initialize(config_path=str(config_path)):
os.environ["AUTOALBUMENT_TEST_DATASET_LENGTH"] = "17"
os.environ["AUTOALBUMENT_CONFIG_DIR"] = str((Path(__file__).parent / config_path).resolve())
os.chdir(tmpdir)
cfg = compose(config_name="search", overrides=["data.dataloader.batch_size=12"])
faa_searcher = get_faa_searcher(cfg)
faa_searcher.search()
def test_compose_config(
self,
config_path: str,
config_file: str,
overrides: List[str],
expected: Any,
) -> None:
with initialize_ctx(config_path=config_path):
cfg = compose(config_file, overrides)
assert cfg == expected
def test_initialize_ctx(
self,
config_file: str,
overrides: List[str],
expected: Any,
) -> None:
with initialize(
config_path="../examples/jupyter_notebooks/cloud_app/conf"):
ret = compose(config_file, overrides)
assert ret == expected
def test_initialize_with_module(hydra_restore_singletons: Any) -> None:
with initialize_config_module(
config_module="tests.test_apps.app_with_cfg_groups.conf",
job_name="my_pp"):
assert compose(config_name="config") == {
"optimizer": {
"type": "nesterov",
"lr": 0.001
}
}
def test_add_config_group(self) -> None:
ConfigStore.instance().store(group="group", name="a0", node={"key": 0})
ConfigStore.instance().store(group="group", name="a1", node={"key": 1})
# overriding non existing group throws
with raises(ConfigCompositionException):
compose(overrides=["group=a0"])
# appending a new group
cfg = compose(overrides=["+group=a0"])
assert cfg == {"group": {"key": 0}}
# force adding is not supported for config groups.
with raises(
ConfigCompositionException,
match=re.escape(
"force-add of config groups is not supported: '++group=a1'"
),
):
compose(overrides=["++group=a1"])
def test_initialize_with_file(restore_singletons: Any) -> None:
initialize_with_file(
calling_file="tests/test_apps/app_with_cfg_groups/my_app.py",
config_path="conf")
assert compose(config_name="config") == {
"optimizer": {
"type": "nesterov",
"lr": 0.001
}
}
def test_adding_to_sc_dict(hydra_restore_singletons: Any, overrides: List[str],
expected: Any) -> None:
@dataclass
class Config:
map: Dict[str, str] = field(default_factory=dict)
ConfigStore.instance().store(name="config", node=Config)
cfg = compose(config_name="config", overrides=overrides)
assert cfg == expected
def test_training_only_cnn_weights(self):
with initialize(config_path=os.path.join("..", "fixtures", "conf")):
config = compose(
config_name="config",
overrides=[
"runner/model=resnet18fusionpolicy",
"runner/dataset=filetextbertforwardsatosapolicy",
"runner/val_dataset=filetextbertforwardsatosapolicy",
"runner.runner_name=SOCTextForwardPolicyRunner"
])
config.runner.dataset.dataset_path = _RAW_TEXT_BERT_DATASET_PATH
config.runner.val_dataset.dataset_path = _RAW_TEXT_BERT_DATASET_PATH
config.runner.train_cnn = True
config.runner.train_fusion = False
config.runner.train_heads = True
config.trainer.default_root_dir = self.folder
config.trainer.fast_dev_run = False
# We rely on seeds to copy the init weights
seed_everything(config['runner']['seed'])
r_copy = make_runner(config['runner'])
r_copy.setup('fit')
seed_everything(config['runner']['seed'])
runner = make_runner(config['runner'])
trainer = Trainer(**config['trainer'], deterministic=True)
trainer.fit(runner)
zipped_params = zip(r_copy.model.fusion.parameters(),
runner.model.fusion.parameters())
for param_copy, param in zipped_params:
assert torch.all(torch.eq(param_copy, param))
zipped_params = zip(r_copy.model.spatial_state_head.parameters(),
runner.model.spatial_state_head.parameters())
for param_copy, param in zipped_params:
assert not torch.all(torch.eq(param_copy, param))
zipped_params = zip(r_copy.model.linear_state_head.parameters(),
runner.model.linear_state_head.parameters())
for param_copy, param in zipped_params:
assert not torch.all(torch.eq(param_copy, param))
# zipped_params = zip(
# r_copy.model.policy_head.parameters(), runner.model.policy_head.parameters()
# )
# for param_copy, param in zipped_params:
# assert not torch.all(torch.eq(param_copy, param))
zipped_params = zip(r_copy.model.cnn.parameters(),
runner.model.cnn.parameters())
for param_copy, param in zipped_params:
assert not torch.all(torch.eq(param_copy, param))
break # Not all layers are learnable so we check only the first one
def setUp(self):
MockedApiWorkflowSetup.setUp(self)
self.create_fake_dataset()
with initialize(config_path="../../lightly/cli/config",
job_name="test_app"):
self.cfg = compose(config_name="config",
overrides=[
"token='123'",
f"input_dir={self.folder_path}",
"trainer.max_epochs=0"
])
def get_features_cfg(cfg):
# Get features configs/overrides
features_overrides = parse_processed_data_overrides(cfg)
features_overrides.extend(parse_override(cfg.lagged_features))
features_cfg = compose(
config_name="compute_lagged_features",
return_hydra_config=True,
overrides=features_overrides,
)
return features_cfg
def get_data_cfg(cfg):
# Get data configs/overrides
data_overrides = parse_data_overrides(cfg)
data_cfg = compose(
config_name="process_data",
return_hydra_config=True,
overrides=data_overrides,
)
return data_cfg
def test_generated_config(self) -> None:
try:
# config is relative to a module
initialize_with_module(calling_module="hydra_app.main", config_path="conf")
cfg = compose(config_name="config", overrides=["app.user=test_user"])
assert cfg == {
"app": {"user": "******", "num1": 10, "num2": 20},
"db": {"host": "localhost", "port": 3306},
}
finally:
GlobalHydra.instance().clear()
def test_schedulers(sch_name: str) -> None:
scheduler_name = sch_name.split('.')[0]
with initialize(config_path='../conf'):
cfg = compose(config_name='config',
overrides=[
f'scheduler={scheduler_name}', 'optimizer=sgd',
'private=default'
])
optimizer = load_obj(cfg.optimizer.class_name)(torch.nn.Linear(
1, 1).parameters(), **cfg.optimizer.params)
load_obj(cfg.scheduler.class_name)(optimizer, **cfg.scheduler.params)
def setUp(self):
self.folder_path, self.sample_names = self.create_dataset_no_subdir(10)
with initialize(config_path='../../lightly/cli/config', job_name='test_app'):
self.cfg = compose(
config_name='config',
overrides=[
'token="123"',
f'input_dir={self.folder_path}',
'trainer.max_epochs=0',
],
)
def test_main():
# Ensure our training script runs top to bottom without errors.
initialize(config_path='../conf')
overrides = dict(num_steps=5,
train_bs=2,
val_bs=2,
test_mode=True,
eval_freq=2,
report_freq=2)
cfg = compose("config.yaml", overrides=[f'{k}={v}' for k, v in overrides.items()])
main(cfg)
def test_compose_config(
self,
config_dir: str,
hydra_global_context: TGlobalHydraContext,
config_file: str,
overrides: List[str],
expected: Any,
) -> None:
with hydra_global_context(config_dir=config_dir):
cfg = compose(config_file, overrides)
assert cfg == expected
def test_compose_decorator(
self,
hydra_global_context: TGlobalHydraContext,
config_dir: str,
config_file: str,
overrides: List[str],
expected: Any,
) -> None:
with hydra_global_context(config_dir=config_dir):
ret = compose(config_file, overrides)
assert ret == expected
def load_hydra_config(file_path):
"""Load a hydra composable config or a single yaml config
:param file_path: path to the hydra main default_config
:return: a DictConfig containing the configuration
"""
file_path = to_absolute_path(file_path)
conf_dir, file_name = os.path.split(file_path)
with initialize_config_dir(conf_dir):
cfg = compose(config_name=file_name)
return cfg
def test_model_save_hyper_parameters_interpolation_with_hydra(tmpdir):
"""
This test relies on configuration saved under tests/models/conf/config.yaml
"""
class TestHydraModel(BoringModel):
def __init__(self, args_0, args_1, args_2, kwarg_1=None):
self.save_hyperparameters()
self.test_hparams()
config_file = f"{tmpdir}/hparams.yaml"
save_hparams_to_yaml(config_file, self.hparams)
self.hparams = load_hparams_from_yaml(config_file)
self.test_hparams()
super().__init__()
def test_hparams(self):
assert self.hparams.args_0.log == "Something"
assert self.hparams.args_1['cfg'].log == "Something"
assert self.hparams.args_2[0].log == "Something"
assert self.hparams.kwarg_1['cfg'][0].log == "Something"
with initialize(config_path="conf"):
args_0 = compose(config_name="config")
args_1 = {"cfg": compose(config_name="config")}
args_2 = [compose(config_name="config")]
kwarg_1 = {"cfg": [compose(config_name="config")]}
model = TestHydraModel(args_0, args_1, args_2, kwarg_1=kwarg_1)
epochs = 2
checkpoint_callback = ModelCheckpoint(monitor=None,
dirpath=tmpdir,
save_top_k=-1)
trainer = Trainer(
default_root_dir=tmpdir,
callbacks=[checkpoint_callback],
limit_train_batches=10,
limit_val_batches=10,
max_epochs=epochs,
logger=False,
)
trainer.fit(model)
_ = TestHydraModel.load_from_checkpoint(
checkpoint_callback.best_model_path)
def test_reward_decoder(overrides: List[str]) -> None:
with initialize(config_path="../../../config"):
config = compose(
config_name="config",
overrides=overrides,
)
batch_size = 128
reward_feature_dim = config.agent.reward_decoder.feature_dim
reward_decoder = RewardDecoder(feature_dim=reward_feature_dim, )
batch = torch.rand((batch_size, reward_feature_dim))
assert reward_decoder(batch).shape == (batch_size, 1)
def load_config(config_path:str='config', config_file:str='config', overrides:dict=None):
"""
Args:
config_path (str):
config_file (str):
Return:
config (dict):
"""
try:
initialize(f'../../{config_path}')
except ValueError:
from hydra.core.global_hydra import GlobalHydra
GlobalHydra.instance().clear()
initialize(f'../../{config_path}')
if overrides is not None:
cfg = compose(config_name=config_file, overrides=overrides)
else:
cfg = compose(config_name=config_file)
return cfg
def setup_pathmanager():
"""
Setup PathManager. A bit hacky -- we use the #set_env_vars method to setup pathmanager
and as such we need to create a dummy config, and dummy values for local_rank and node_id.
"""
with initialize_config_module(config_module="vissl.config"):
cfg = compose(
"defaults",
overrides=["config=test/integration_test/quick_swav"],
)
config = AttrDict(cfg).config
set_env_vars(local_rank=0, node_id=0, cfg=config)
