def run(cfg): # Hack to load with liftoff import sys # Hack to move configs from liftoff sys.argv = [ sys.argv[0], ] + [f"{k}={v}" for k, v in flatten_cfg(cfg)] main_wrapper = hydra.main('config.yaml', strict=False) main_wrapper(main)()
def task_script_wrapper(script_func: TaskFunction) -> TaskFunction: @functools.wraps(script_func) def process_config_and_run_main(cfg: "DictConfig"): operator, cfg = process_config_and_get_operator(cfg) try: ret_val = script_func(operator, cfg) except Exception as e: raise e finally: if not operator.is_shutdown: operator.shutdown() return ret_val absolute_config_path = os.path.abspath( os.path.join(get_run_file_dir(), config_path)) hydra_wrapper = hydra.main(config_path=absolute_config_path, config_name="taskconfig") return cast(TaskFunction, hydra_wrapper(process_config_and_run_main))
import torch from homura.modules import cross_entropy_with_softlabels from torch.nn import functional as F from backends.utils import SSLTrainerBase, disable_bn_stats, get_task class PseudoLabelTrainer(SSLTrainerBase): def labeled(self, input: torch.Tensor, target: torch.Tensor) -> (torch.Tensor, torch.Tensor): target = self.to_onehot(target, self.smoothing) output = self.model(input) loss = self.loss_f(output, target) return output, loss def unlabeled(self, input: torch.Tensor) -> (torch.Tensor, torch.Tensor): with disable_bn_stats(self.model): u_output = self.model(input) u_loss = F.cross_entropy(u_output, u_output.argmax(dim=1), reduction='none') u_loss = ((u_loss > self.threshold).float() * u_loss).mean() return u_output, u_loss if __name__ == "__main__": import hydra hydra.main('config/pseudo_label.yaml')(get_task( PseudoLabelTrainer, cross_entropy_with_softlabels))()
nlp = cast(TorchLanguage, create_model(cfg.model)) train_data = list( srsly.read_jsonl(os.path.join(org_cwd, cfg.train.data.train))) cfg.train.data.ndata = len(train_data) val_data = list(srsly.read_jsonl(os.path.join(org_cwd, cfg.train.data.val))) logger.info("output dir: {}".format(os.getcwd())) if torch.cuda.is_available(): logger.info("CUDA enabled") nlp.to(torch.device("cuda")) savedir = Path.cwd() / "models" srsly.write_jsonl(Path.cwd() / f"train-data.jsonl", train_data) srsly.write_jsonl(Path.cwd() / f"val-data.jsonl", val_data) savedir.mkdir(exist_ok=True) train(cfg.train, nlp, train_data, val_data, savedir) if __name__ == "__main__": from util import get_relative_path if len(sys.argv) != 2: print('python train.py [your train_(intent|slot).yaml]', file=sys.stderr) sys.exit(0) config_path = sys.argv.pop() if not os.path.exists(config_path): print(f'{config_path} is not found.', file=sys.stderr) sys.exit(0) rel_path = get_relative_path(config_path) main = hydra.main(config_path=rel_path, strict=False)(_main) main()
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved from omegaconf import DictConfig import hydra from hydra.core.hydra_config import HydraConfig class MyCallable: def __init__(self, state: int = 123) -> None: self._state = state def __call__(self, cfg: DictConfig) -> None: print(self._state) print(HydraConfig.get().job.name) my_callable = MyCallable() my_app = hydra.main(version_base=None)(my_callable) if __name__ == "__main__": my_app()
log.exception(err) _exceptions.append(err) else: raise err finally: # flush logger to ensure free memory for next run if trainer is not None: experiment = trainer.logger.experiment # type: ignore if experiment is not None and hasattr(experiment, "flush"): experiment.flush() log.debug("Flushed experiment to disk") if experiment is not None and hasattr(experiment, "close"): experiment.close() log.debug("Closed experiment writer") # postprocess results if desired (e.g. to scalars for bayesian optimization) if process_results_fn is not None: log.debug("Running results postprocessing") output = process_results_fn(train_results, test_results) # type: ignore else: output = train_results, test_results return output # type: ignore if __name__ == "__main__": _main = hydra.main(config_path="./conf/config.yaml")(main) _main()
F = solve_F(points_list, K) if F is None: logger.info('Could not solve F.') return logger.info(f"\n{F=}") logger.info(f"{np.linalg.eig(F)[0]=}") # Line epipolar utils.save_lined_epipolar_image(F.T, images_list[0], points_list[0], points_list[1], 0) utils.save_lined_epipolar_image(F, images_list[1], points_list[1], points_list[0], 1) utils.save_lined_epipolar_image(F.T, images_list[0], test_points_list[0], test_points_list[1], 0, prefix='test_') utils.save_lined_epipolar_image(F, images_list[1], test_points_list[1], test_points_list[0], 1, prefix='test_') return if __name__ == "__main__": hydra.main(config_path='../conf/config.yaml')(main)()
target = self.to_onehot(target, self.smoothing) s_loss = self.loss_f[0](output, target) return output, s_loss def unlabeled(self, input: torch.Tensor) -> (None, torch.Tensor, torch.Tensor): with disable_bn_stats(self.model): logits = self.model(input) u_loss = self.vat_loss(input, logits.clone().detach()) e_loss = Categorical(logits=logits).entropy().mean() return None, u_loss, e_loss def vat_loss(self, input: torch.Tensor, logits: torch.Tensor) -> torch.Tensor: d = normalize(input.clone().normal_()) d.requires_grad_(True) pred_hat = self.model(input + self.xi * d) adv_loss = kl_div(logits, pred_hat) d_grad, = torch.autograd.grad([adv_loss], [d]) d = normalize(d_grad) self.model.zero_grad() pred_hat = self.model(input + self.eps * d) return kl_div(logits, pred_hat) if __name__ == "__main__": import hydra hydra.main('config/vat.yaml')(get_task( VATTrainer, [cross_entropy_with_softlabels, F.cross_entropy]))()
from omegaconf import OmegaConf, DictConfig from artefact_nca.config.config_utils import setup_config from artefact_nca.trainer.voxel_ca_trainer import VoxelCATrainer def train(cfg: DictConfig): if "trainer" not in cfg: cfg["trainer"] = {} else: cfg = OmegaConf.to_container(cfg) cfg["trainer"].pop("config") ct = VoxelCATrainer.from_config(config=cfg["trainer"]) ct.train() if __name__ == "__main__": setup_config() config_path = None config_name = None hydra_args = "hydra.run.dir=. hydra.output_subdir=null hydra/job_logging=disabled hydra/hydra_logging=disabled".split(" ") if len(sys.argv) > 1 and sys.argv[1].startswith("config="): config_path = sys.argv[1].split("=")[-1] sys.argv.pop(1) sys.argv.extend(hydra_args) config_path = os.path.abspath(config_path) config_path, config_name = os.path.split(config_path) config_name = config_name.replace(".yaml", "") main_wrapper = hydra.main(config_path=config_path, config_name=config_name) main_wrapper(train)()
workspace.run() def run(cfg): # Hack to load with liftoff import sys # Hack to move configs from liftoff sys.argv = [ sys.argv[0], ] + [f"{k}={v}" for k, v in flatten_cfg(cfg)] main_wrapper = hydra.main('config.yaml', strict=False) main_wrapper(main)() if __name__ == "__main__": import sys cfg = parse_opts() # Hack to move configs from liftoff ftcfg = flatten_cfg(cfg) # ftcfg = [('seed', 0), ('log_save_tb', False), ('save_video', False), ('log_save_wandb', False), ('replay_buffer_augmentation', True), ('out_dir', 'results/experiment_configs'), ('run_id', 1)] sys.argv = [ sys.argv[0], ] + [f"{k}={v}" for k, v in ftcfg] main_wrapper = hydra.main('config.yaml', strict=False) main_wrapper(main)()
import torch from homura.modules import cross_entropy_with_softlabels, to_onehot from torch.nn import functional as F from backends.utils import SSLTrainerBase, disable_bn_stats, get_task class MeanTeacherTrainer(SSLTrainerBase): def labeled(self, input: torch.Tensor, target: torch.Tensor) -> (torch.Tensor, torch.Tensor): output = self.model(input) target = to_onehot(target, self.num_classes) target -= self.smoothing * (target - 1 / self.num_classes) loss = self.loss_f(output, target) return output, loss def unlabeled(self, input1: torch.Tensor, input2: torch.Tensor) -> (torch.Tensor, torch.Tensor): with disable_bn_stats(self.model): o1 = self.model(input1) with torch.no_grad(): o2 = self.ema(input2) return o1, F.mse_loss(o1.softmax(dim=1), o2.softmax(dim=1)) if __name__ == "__main__": import hydra hydra.main('config/mean_teacher.yaml')(get_task( MeanTeacherTrainer, cross_entropy_with_softlabels))()
loss = self.loss_f[0](output, target) return output, loss def unlabeled(self, input: torch.Tensor): with torch.no_grad(): expected = self.ema(input).softmax(dim=-1) input, expected = self.mixup(input, expected) output = self.model(input) loss = self.loss_f[1](output, expected) return output, loss def mixup(self, input: torch.Tensor, target: torch.Tensor): if not torch.is_tensor(self.beta): # very important for speed up self.beta = torch.tensor(self.beta).to(self.device) gamma = Beta(self.beta, self.beta).sample((input.size(0), 1, 1, 1)) perm = torch.randperm(input.size(0)) perm_input = input[perm] perm_target = target[perm] input.mul_(gamma).add_(perm_input.mul_(1 - gamma)) gamma = gamma.view(-1, 1) target.mul_(gamma).add_(perm_target.mul_(1 - gamma)) return input, target if __name__ == '__main__': import hydra hydra.main('config/ict.yaml')(get_task( ICTTrainer, [cross_entropy_with_softlabels, mse_with_logits]))()
from pytorch_modules.engine import build_modules, load_obj def run(cfg): print(cfg.pretty()) tb_logger = TensorBoardLogger(save_dir=cfg.general.save_dir) checkpoint_callback = build_modules(cfg.checkpoint) model = load_obj(cfg.model.model_name)(cfg) callbacks = build_modules(cfg.callbacks) trainer = pl.Trainer(logger=tb_logger, checkpoint_callback=checkpoint_callback, callbacks=callbacks, **cfg.trainer) trainer.fit(model) if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--config_path', default='conf/config.yaml', type=str, help='Your config file path.') parser.add_argument('--strict', action='store_true', help='Strict mode for hydra.') opt, left = parser.parse_known_args() sys.argv = sys.argv[:1] + left hydra_wrapper = hydra.main(config_path=opt.config_path, strict=opt.strict) hydra_wrapper(run)()
torch.cuda.manual_seed_all(seed) # type: ignore def _main(cfg: Config) -> None: if cfg.user_config is not None: # Override config by user config. # This `user_config` have some limitations, and it will be improved # after the issue https://github.com/facebookresearch/hydra/issues/386 solved cfg = OmegaConf.merge( cfg, OmegaConf.load(hydra.utils.to_absolute_path(cfg.user_config))) cfg = parse(cfg) if cfg.seed: set_seed(cfg.seed) logger.info(cfg.pretty()) train_data, val_data = create_data(cfg.train.data) nlp = cast(TorchLanguage, create_model(cfg.model)) logger.info("output dir: {}".format(os.getcwd())) if torch.cuda.is_available(): logger.info("CUDA enabled") nlp.to(torch.device("cuda")) savedir = Path.cwd() / "models" savedir.mkdir(exist_ok=True) train(cfg.train, nlp, train_data, val_data, savedir) # Avoid to use decorator for testing main = hydra.main(config_path="conf/train/config.yaml", strict=False)(_main) if __name__ == "__main__": main()
def data_handle(self, data: Tuple) -> Tuple: pillow_aug = (len(data) == 5) if pillow_aug: # Pillow augmentation input, target, u_x1, u_x2, _ = data u_x, u_y = self.sharpen((u_x1, u_x2)) else: input, target, u_x, _ = data u_x, u_y = self.sharpen(u_x) # l_x, l_y, u_x, u_y return input, self.to_onehot(target), u_x, u_y def sharpen(self, input: torch.Tensor or Tuple) -> Tuple[torch.Tensor, torch.Tensor]: u_b = torch.cat(input, dim=0) with disable_bn_stats(self.model): q_b = (self.model(input[0]).softmax(dim=1) + self.model(input[1]).softmax(dim=1)) / 2 q_b.pow_(1 / self.temperature).div_(q_b.sum(dim=1, keepdim=True)) return u_b, q_b.repeat(2, 1) if __name__ == "__main__": import hydra hydra.main('config/mixmatch.yaml')( get_task(MixmatchTrainer, [cross_entropy_with_softlabels, F.mse_loss]) )()
def hydra_init(config_path='conf', config_name='config', strict=None): return hydra.main(config_name=config_name, config_path=config_path, strict=strict)