File size: 6,048 Bytes
484b847 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 |
import os
import logging
from functools import partial
import hydra
import torch
import wandb
from hydra.core.hydra_config import HydraConfig
from hydra.utils import instantiate
from lightning import seed_everything
from omegaconf import DictConfig, OmegaConf
from pdeinvbench.utils import validate_git_status
from pdeinvbench.utils.config_utils import resolve_pde_resolution
import sys
import pdeinvbench
# Add any other submodules you need
@hydra.main(
version_base=None,
config_path="configs/",
config_name="1dkdv",
)
def main(cfg: DictConfig) -> None:
# check git dirty status
validate_git_status()
hydra_cfg = HydraConfig.get()
overrides = hydra_cfg.overrides.task
overrides = [
override
for override in overrides
if "data_root" not in override
and "batch_size" not in override
and "logging.project" not in override
and "logging.save_dir" not in override
and "num_nodes" not in override
and "log_model" not in override
and "supervised_learning_min_epoch" not in override
and "supervised_learning_max_epoch" not in override
]
# First thing is to determine the constants
resolve_pde_resolution(cfg)
# Combine the config name with overrides:
wandb_name = hydra_cfg.job["config_name"] + "_" + "_".join(overrides)
# Fix random seed
seed_everything(cfg.seed)
# Define logger
# Arguments for wandb.init
wandb_args = OmegaConf.to_container(
cfg.logging, resolve=True, throw_on_missing=True
)
# Remove the _target_ key which usually points to the lightning logger
wandb_args.pop("_target_")
# Rename the save_dir key to dir, which is what wandb.init expects
# We keep save_dir in cfg.logging so that we can still resolve the lightning wandb logger
wandb_args["dir"] = wandb_args.pop("save_dir")
cfg_as_dict = OmegaConf.to_container(
cfg, resolve=True, throw_on_missing=True)
# Manually instantiate the wandb experiment
# We do this so that the wandb run is created with the correct parameters to recreate the run at the start.
# Otherwise, the config is only saved at the end of the run.
experiment = wandb.init(**wandb_args, name=wandb_name, config=cfg_as_dict)
# Instantiate dataloaders
train_dataloader = instantiate(cfg.data.train_dataloader)
val_dataloaders = []
test_dataloaders = []
val_dataloader = instantiate(cfg.data.val_dataloader)
val_dataloaders.append(val_dataloader)
# to run validation set at test time as well with best weights
test_dataloaders.append(val_dataloader)
if "ood_dataloader" in cfg.data.keys() and os.path.exists(cfg.data.ood_data_root):
print("ood loader")
test_dataloaders.append(instantiate(cfg.data.ood_dataloader))
if "ood_dataloader_extreme" in cfg.data.keys() and os.path.exists(
cfg.data.ood_data_root_extreme
):
print("ood loader extreme")
test_dataloaders.append(instantiate(cfg.data.ood_dataloader_extreme))
if "test_dataloader" in cfg.data.keys() and os.path.exists(cfg.data.test_data_root):
print("test iid loader")
test_dataloaders.append(instantiate(cfg.data.test_dataloader))
# Instantiate model and optimizer
model = instantiate(cfg.model.model_config)
if "inverse_model_wandb_run" in cfg.keys() and cfg.inverse_model_wandb_run != "":
logging.info("Loading inverse model checkpoint from wandb")
inverse_model_run_path = cfg.inverse_model_wandb_run
artifact = experiment.use_artifact(
inverse_model_run_path, type="model")
checkpoint_path = os.path.join(artifact.download(), "model.ckpt")
state_dict = torch.load(checkpoint_path, weights_only=False)[
"state_dict"]
state_dict = {k.partition(
"model.")[2]: v for k, v in state_dict.items()}
model.load_state_dict(state_dict)
optimizer = instantiate(cfg.optimizer, params=model.parameters())
lr_scheduler = instantiate(cfg.lr_scheduler, optimizer=optimizer)
module_kwargs = {
"model": model,
"optimizer": optimizer,
"lr_scheduler": lr_scheduler,
}
if "tailoring_optimizer" in cfg.keys():
# We use a partial function so that we can dynamically build new optimizers
def tailoring_optimizer(x):
return instantiate(cfg.tailoring_optimizer, params=x)
module_kwargs["tailoring_optimizer"] = tailoring_optimizer
else:
tailoring_optimizer = None
# Wraps the base model to perform prediction and losses
if tailoring_optimizer != None:
print(cfg.tailoring_optimizer)
print("instantiate inverse module")
Inverse_module = instantiate(
cfg.lightning_module,
**module_kwargs,
)
print("instantiate inverse module done")
# Instantiate the lightning logger & force the lightning logger to use the wandb experiment manually created
log_model = "all"
if "log_model" in cfg:
log_model = cfg.log_model
logger = instantiate(
cfg.logging, experiment=experiment, log_model=log_model)
logger._save_dir += "/" + \
cfg_as_dict["logging"]["project"] + "/" + wandb_name
logger.watch(model, log="all")
# Lightning trainer
if tailoring_optimizer is not None:
L_trainer = instantiate(
cfg.trainer,
logger=logger,
inference_mode=False,
)
else:
L_trainer = instantiate(cfg.trainer, logger=logger)
if "test_run" in cfg and cfg.test_run:
L_trainer.test(model=Inverse_module,
dataloaders=test_dataloaders, weights_only=False)
else:
# Train
L_trainer.fit(
Inverse_module,
train_dataloaders=train_dataloader,
val_dataloaders=val_dataloaders,
)
L_trainer.test(dataloaders=test_dataloaders,
ckpt_path="best", weights_only=False)
if __name__ == "__main__":
main()
|