xautodl/exps/experimental/GeMOSA/basic-same.py

229 lines
7.4 KiB
Python
Raw Normal View History

2021-04-29 13:06:45 +02:00
#####################################################
# Copyright (c) Xuanyi Dong [GitHub D-X-Y], 2021.04 #
#####################################################
2021-05-27 10:09:28 +02:00
# python exps/GeMOSA/basic-same.py --env_version v1 --hidden_dim 16 --epochs 500 --init_lr 0.1 --device cuda
# python exps/GeMOSA/basic-same.py --env_version v2 --hidden_dim 16 --epochs 500 --init_lr 0.1 --device cuda
# python exps/GeMOSA/basic-same.py --env_version v3 --hidden_dim 32 --epochs 1000 --init_lr 0.05 --device cuda
2021-05-27 13:47:08 +02:00
# python exps/GeMOSA/basic-same.py --env_version v4 --hidden_dim 32 --epochs 1000 --init_lr 0.05 --device cuda
2021-04-29 13:06:45 +02:00
#####################################################
import sys, time, copy, torch, random, argparse
from tqdm import tqdm
from copy import deepcopy
from pathlib import Path
2021-05-24 07:38:02 +02:00
lib_dir = (Path(__file__).parent / ".." / "..").resolve()
print("LIB-DIR: {:}".format(lib_dir))
if str(lib_dir) not in sys.path:
sys.path.insert(0, str(lib_dir))
2021-05-19 10:20:44 +02:00
from xautodl.procedures import (
prepare_seed,
prepare_logger,
save_checkpoint,
copy_checkpoint,
)
from xautodl.log_utils import time_string
from xautodl.log_utils import AverageMeter, convert_secs2time
2021-04-29 13:06:45 +02:00
2021-05-19 10:20:44 +02:00
from xautodl.utils import split_str2indexes
2021-04-29 13:06:45 +02:00
2021-05-27 13:47:08 +02:00
from xautodl.procedures.metric_utils import (
SaveMetric,
MSEMetric,
Top1AccMetric,
ComposeMetric,
)
2021-05-19 10:20:44 +02:00
from xautodl.datasets.synthetic_core import get_synthetic_env
from xautodl.models.xcore import get_model
2021-04-29 13:06:45 +02:00
def subsample(historical_x, historical_y, maxn=10000):
total = historical_x.size(0)
if total <= maxn:
return historical_x, historical_y
else:
indexes = torch.randint(low=0, high=total, size=[maxn])
return historical_x[indexes], historical_y[indexes]
def main(args):
2021-05-27 10:09:28 +02:00
prepare_seed(args.rand_seed)
logger = prepare_logger(args)
2021-05-24 07:38:02 +02:00
env = get_synthetic_env(mode=None, version=args.env_version)
2021-05-27 10:09:28 +02:00
model_kwargs = dict(
config=dict(model_type="norm_mlp"),
input_dim=env.meta_info["input_dim"],
output_dim=env.meta_info["output_dim"],
hidden_dims=[args.hidden_dim] * 2,
act_cls="relu",
norm_cls="layer_norm_1d",
)
2021-05-24 07:38:02 +02:00
logger.log("The total enviornment: {:}".format(env))
w_containers = dict()
2021-05-07 08:27:15 +02:00
2021-05-27 13:47:08 +02:00
if env.meta_info["task"] == "regression":
criterion = torch.nn.MSELoss()
metric_cls = MSEMetric
elif env.meta_info["task"] == "classification":
criterion = torch.nn.CrossEntropyLoss()
metric_cls = Top1AccMetric
else:
raise ValueError(
"This task ({:}) is not supported.".format(all_env.meta_info["task"])
)
2021-04-29 13:06:45 +02:00
per_timestamp_time, start_time = AverageMeter(), time.time()
2021-05-24 07:38:02 +02:00
for idx, (future_time, (future_x, future_y)) in enumerate(env):
2021-04-29 13:06:45 +02:00
need_time = "Time Left: {:}".format(
2021-05-24 07:38:02 +02:00
convert_secs2time(per_timestamp_time.avg * (len(env) - idx), True)
2021-04-29 13:06:45 +02:00
)
logger.log(
"[{:}]".format(time_string())
2021-05-24 07:38:02 +02:00
+ " [{:04d}/{:04d}]".format(idx, len(env))
2021-04-29 13:06:45 +02:00
+ " "
+ need_time
)
# train the same data
2021-05-24 07:38:02 +02:00
historical_x = future_x.to(args.device)
historical_y = future_y.to(args.device)
2021-04-29 13:06:45 +02:00
# build model
2021-05-12 12:58:54 +02:00
model = get_model(**model_kwargs)
2021-05-24 07:38:02 +02:00
model = model.to(args.device)
2021-05-26 10:53:44 +02:00
if idx == 0:
print(model)
2021-04-29 13:06:45 +02:00
# build optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=args.init_lr, amsgrad=True)
lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(
optimizer,
milestones=[
int(args.epochs * 0.25),
int(args.epochs * 0.5),
int(args.epochs * 0.75),
],
gamma=0.3,
)
2021-05-27 13:47:08 +02:00
train_metric = metric_cls(True)
2021-04-29 13:06:45 +02:00
best_loss, best_param = None, None
for _iepoch in range(args.epochs):
preds = model(historical_x)
optimizer.zero_grad()
loss = criterion(preds, historical_y)
loss.backward()
optimizer.step()
lr_scheduler.step()
# save best
if best_loss is None or best_loss > loss.item():
best_loss = loss.item()
best_param = copy.deepcopy(model.state_dict())
model.load_state_dict(best_param)
2021-05-13 10:39:19 +02:00
model.analyze_weights()
2021-04-29 13:06:45 +02:00
with torch.no_grad():
train_metric(preds, historical_y)
train_results = train_metric.get_info()
2021-05-27 13:47:08 +02:00
xmetric = ComposeMetric(metric_cls(True), SaveMetric())
2021-04-29 13:06:45 +02:00
eval_dataset = torch.utils.data.TensorDataset(
2021-05-24 07:38:02 +02:00
future_x.to(args.device), future_y.to(args.device)
2021-04-29 13:06:45 +02:00
)
eval_loader = torch.utils.data.DataLoader(
eval_dataset, batch_size=args.batch_size, shuffle=False, num_workers=0
)
2021-05-27 13:47:08 +02:00
results = basic_eval_fn(eval_loader, model, xmetric, logger)
2021-04-29 13:06:45 +02:00
log_str = (
"[{:}]".format(time_string())
2021-05-24 07:38:02 +02:00
+ " [{:04d}/{:04d}]".format(idx, len(env))
2021-05-27 13:47:08 +02:00
+ " train-score: {:.5f}, eval-score: {:.5f}".format(
train_results["score"], results["score"]
2021-04-29 13:06:45 +02:00
)
)
logger.log(log_str)
2021-05-24 07:38:02 +02:00
save_path = logger.path(None) / "{:04d}-{:04d}.pth".format(idx, len(env))
w_containers[idx] = model.get_w_container().no_grad_clone()
2021-04-29 13:06:45 +02:00
save_checkpoint(
{
2021-04-29 13:48:21 +02:00
"model_state_dict": model.state_dict(),
"model": model,
2021-04-29 13:06:45 +02:00
"index": idx,
2021-05-24 07:38:02 +02:00
"timestamp": future_time.item(),
2021-04-29 13:06:45 +02:00
},
save_path,
logger,
)
logger.log("")
per_timestamp_time.update(time.time() - start_time)
start_time = time.time()
2021-05-09 19:02:38 +02:00
2021-05-07 08:27:15 +02:00
save_checkpoint(
2021-05-24 07:38:02 +02:00
{"w_containers": w_containers},
2021-05-07 08:27:15 +02:00
logger.path(None) / "final-ckp.pth",
logger,
)
2021-04-29 13:06:45 +02:00
logger.log("-" * 200 + "\n")
logger.close()
if __name__ == "__main__":
2021-04-29 13:11:48 +02:00
parser = argparse.ArgumentParser("Use the data in the past.")
2021-04-29 13:06:45 +02:00
parser.add_argument(
"--save_dir",
type=str,
2021-05-27 10:09:28 +02:00
default="./outputs/GeMOSA-synthetic/use-same-timestamp",
2021-04-29 13:06:45 +02:00
help="The checkpoint directory.",
)
2021-05-09 19:02:38 +02:00
parser.add_argument(
"--env_version",
type=str,
required=True,
help="The synthetic enviornment version.",
)
parser.add_argument(
2021-05-17 04:31:26 +02:00
"--hidden_dim",
type=int,
required=True,
help="The hidden dimension.",
2021-05-09 19:02:38 +02:00
)
2021-04-29 13:06:45 +02:00
parser.add_argument(
"--init_lr",
type=float,
default=0.1,
help="The initial learning rate for the optimizer (default is Adam)",
)
parser.add_argument(
2021-05-17 04:31:26 +02:00
"--batch_size",
type=int,
default=512,
help="The batch size",
2021-04-29 13:06:45 +02:00
)
parser.add_argument(
2021-05-17 04:31:26 +02:00
"--epochs",
type=int,
default=300,
help="The total number of epochs.",
2021-04-29 13:06:45 +02:00
)
2021-05-24 07:38:02 +02:00
parser.add_argument(
"--device",
type=str,
default="cpu",
help="",
)
2021-04-29 13:06:45 +02:00
parser.add_argument(
"--workers",
type=int,
default=4,
help="The number of data loading workers (default: 4)",
)
# Random Seed
parser.add_argument("--rand_seed", type=int, default=-1, help="manual seed")
args = parser.parse_args()
if args.rand_seed is None or args.rand_seed < 0:
args.rand_seed = random.randint(1, 100000)
assert args.save_dir is not None, "The save dir argument can not be None"
2021-05-15 10:01:40 +02:00
args.save_dir = "{:}-d{:}_e{:}_lr{:}-env{:}".format(
args.save_dir, args.hidden_dim, args.epochs, args.init_lr, args.env_version
2021-05-09 19:02:38 +02:00
)
2021-04-29 13:06:45 +02:00
main(args)