# Wrappers
#env = wrappers.Monitor(env, './videos/train/' + time_str + '/', force=True)
#env = CropWrapper(env)
env = ResizeWrapper(env)
#env = FrameStack(env, k = args.frame_stack_k)
env = NormalizeWrapper(env)
env = ImgWrapper(env) # to make the images from 160x120x3 into 3x160x120
env = SteeringToWheelVelWrapper(env)
#env = StableRewardWrapper(env)
#env = ActionWrapper(env)
#env = SoftActionWrapper(env)
env = DtRewardWrapper(env)
# Set seeds
seed(args.seed)
state_dim = env.observation_space.shape
action_dim = env.action_space.shape[0]
max_action = float(env.action_space.high[0])
# Initialize policy
policy = TD3(state_dim, action_dim, max_action, net_type=args.net_type, args = args, device=device)
if args.load_model:
policy.load("TD3_2_debug_0_best", "./pytorch_models{}/TD3_2_debug_0".format(args.epi_load))
print("load suceed!")
if not args.priority_replay:
replay_buffer = ReplayBuffer(args.replay_buffer_max_size)
else:
def tuner(icm_lr, reward_weighting, normalise_rewards, args):
import argparse
import datetime
import torch
import torch_ac
import tensorboardX
import sys
import numpy as np
from model import ACModel
from .a2c import A2CAlgo
# from .ppo import PPOAlgo
frames_to_visualise = 200
# Parse arguments
args.mem = args.recurrence > 1
def make_exploration_heatmap(args, plot_title):
import numpy as np
import matplotlib.pyplot as plt
visitation_counts = np.load(
f"{args.model}_visitation_counts.npy", allow_pickle=True
)
plot_title = str(np.count_nonzero(visitation_counts)) + args.model
plt.imshow(np.log(visitation_counts))
plt.colorbar()
plt.title(plot_title)
plt.savefig(f"{plot_title}_visitation_counts.png")
# Set run dir
date = datetime.datetime.now().strftime("%y-%m-%d-%H-%M-%S")
default_model_name = f"{args.env}_{args.algo}_seed{args.seed}_{date}"
model_name = args.model or default_model_name
model_dir = utils.get_model_dir(model_name)
# Load loggers and Tensorboard writer
txt_logger = utils.get_txt_logger(model_dir)
csv_file, csv_logger = utils.get_csv_logger(model_dir)
tb_writer = tensorboardX.SummaryWriter(model_dir)
# Log command and all script arguments
txt_logger.info("{}\n".format(" ".join(sys.argv)))
txt_logger.info("{}\n".format(args))
# Set seed for all randomness sources
utils.seed(args.seed)
# Set device
device = "cpu" # torch.device("cuda" if torch.cuda.is_available() else "cpu")
txt_logger.info(f"Device: {device}\n")
# Load environments
envs = []
for i in range(16):
an_env = utils.make_env(
args.env, int(args.frames_before_reset), int(args.environment_seed)
)
envs.append(an_env)
txt_logger.info("Environments loaded\n")
# Load training status
try:
status = utils.get_status(model_dir)
except OSError:
status = {"num_frames": 0, "update": 0}
txt_logger.info("Training status loaded\n")
# Load observations preprocessor
obs_space, preprocess_obss = utils.get_obss_preprocessor(envs[0].observation_space)
if "vocab" in status:
preprocess_obss.vocab.load_vocab(status["vocab"])
txt_logger.info("Observations preprocessor loaded")
# Load model
acmodel = ACModel(obs_space, envs[0].action_space, args.mem, args.text)
if "model_state" in status:
acmodel.load_state_dict(status["model_state"])
acmodel.to(device)
txt_logger.info("Model loaded\n")
txt_logger.info("{}\n".format(acmodel))
# Load algo
# adapted from impact driven RL
from .models import AutoencoderWithUncertainty
autoencoder = AutoencoderWithUncertainty(observation_shape=(7, 7, 3)).to(device)
autoencoder_opt = torch.optim.Adam(
autoencoder.parameters(), lr=icm_lr, weight_decay=0
)
if args.algo == "a2c":
algo = A2CAlgo(
envs,
acmodel,
autoencoder,
autoencoder_opt,
args.uncertainty,
args.noisy_tv,
args.curiosity,
args.randomise_env,
args.uncertainty_budget,
args.environment_seed,
reward_weighting,
normalise_rewards,
args.frames_before_reset,
device,
args.frames_per_proc,
args.discount,
args.lr,
args.gae_lambda,
args.entropy_coef,
args.value_loss_coef,
args.max_grad_norm,
args.recurrence,
args.optim_alpha,
args.optim_eps,
preprocess_obss,
None,
args.random_action,
)
elif args.algo == "ppo":
algo = PPOAlgo(
envs,
acmodel,
autoencoder,
autoencoder_opt,
args.uncertainty,
args.noisy_tv,
args.curiosity,
args.randomise_env,
args.uncertainty_budget,
args.environment_seed,
reward_weighting,
normalise_rewards,
device,
args.frames_per_proc,
args.discount,
args.lr,
args.gae_lambda,
args.entropy_coef,
args.value_loss_coef,
args.max_grad_norm,
args.recurrence,
args.optim_eps,
args.clip_eps,
args.epochs,
args.batch_size,
preprocess_obss,
)
else:
raise ValueError("Incorrect algorithm name: {}".format(args.algo))
if "optimizer_state" in status:
algo.optimizer.load_state_dict(status["optimizer_state"])
txt_logger.info("Optimizer loaded\n")
# Train model
num_frames = status["num_frames"]
update = status["update"]
start_time = time.time()
while num_frames < args.frames:
# Update model parameters
update_start_time = time.time()
exps, logs1 = algo.collect_experiences()
logs2 = algo.update_parameters(exps)
logs = {**logs1, **logs2}
update_end_time = time.time()
num_frames += logs["num_frames"]
update += 1
log_to_wandb(logs, start_time, update_start_time, update_end_time)
# Print logs
if update % args.log_interval == 0:
fps = logs["num_frames"] / (update_end_time - update_start_time)
duration = int(time.time() - start_time)
return_per_episode = utils.synthesize(logs["return_per_episode"])
rreturn_per_episode = utils.synthesize(logs["reshaped_return_per_episode"])
num_frames_per_episode = utils.synthesize(logs["num_frames_per_episode"])
header = ["update", "frames", "FPS", "duration"]
data = [update, num_frames, fps, duration]
header += ["rreturn_" + key for key in rreturn_per_episode.keys()]
data += rreturn_per_episode.values()
header += ["num_frames_" + key for key in num_frames_per_episode.keys()]
data += num_frames_per_episode.values()
header += [
"intrinsic_rewards",
"uncertainties",
"novel_states_visited",
"entropy",
"value",
"policy_loss",
"value_loss",
"grad_norm",
]
data += [
logs["intrinsic_rewards"].mean().item(),
logs["uncertainties"].mean().item(),
logs["novel_states_visited"].mean().item(),
logs["entropy"],
logs["value"],
logs["policy_loss"],
logs["value_loss"],
logs["grad_norm"],
]
txt_logger.info(
"U {} | F {:06} | FPS {:04.0f} | D {} | rR:μσmM {:.2f} {:.2f} {:.2f} {:.2f} | F:μσmM {:.1f} {:.1f} {} {} | H {:.3f} | V {:.3f} | pL {:.3f}".format(
*data
)
)
# Save status
if args.save_interval > 0 and update % args.save_interval == 0:
status = {
"num_frames": num_frames,
"update": update,
"model_state": acmodel.state_dict(),
"optimizer_state": algo.optimizer.state_dict(),
}
if hasattr(preprocess_obss, "vocab"):
status["vocab"] = preprocess_obss.vocab.vocab
utils.save_status(status, model_dir)
return
type=int,
default=1000,
help="number of episodes of evaluation (default: 1000)")
parser.add_argument("--seed",
type=int,
default=0,
help="random seed (default: 0)")
parser.add_argument("--argmax",
action="store_true",
default=False,
help="action with highest probability is selected")
args = parser.parse_args()
# Set seed for all randomness sources
utils.seed(args.seed)
# Generate environment
env = gym.make(args.env)
env.seed(args.seed)
# Define agent
save_dir = utils.get_save_dir(args.model)
agent = utils.Agent(save_dir, env.observation_space, args.argmax)
# Initialize logs
logs = {"num_frames_per_episode": [], "return_per_episode": []}
def main(env_name, seed, meta, load_id, procs, fullObs, POfullObs, frames,
log_interval, save_interval, experimental, _run):
"""Main function.
Called by sacred with arguments filled in from default.yaml or command line.
"""
# Make a bunch of experimental options available everywhere for easy change
for cfg in experimental:
setattr(exp_config, cfg, experimental[cfg])
cuda = torch.cuda.is_available()
device = torch.device("cuda" if cuda else "cpu")
model_name = meta['label'] + "_{}".format(_run._id)
model_dir = utils.get_model_dir(model_name)
# Define logger, CSV writer and Tensorboard writer
logger = utils.get_logger(model_dir)
csv_file, csv_writer = utils.get_csv_writer(model_dir)
# Log command and all script arguments
logger.info("{}\n".format(" ".join(sys.argv)))
# Set seed for all randomness sources
utils.seed(seed)
# Generate environments
envs = []
for i in range(procs):
env = gym.make(env_name)
env.seed(seed + 10000 * i)
if fullObs:
env = gym_minigrid.wrappers.FullyObsWrapper(env)
elif POfullObs:
env = gym_minigrid.wrappers.PartialObsFullGridWrapper(env)
envs.append(env)
# Define obss preprocessor
obs_space, preprocess_obss = utils.get_obss_preprocessor(
env_name, envs[0].observation_space, model_dir)
# Load training status
if load_id is not None:
model1, model2, status = utils.load_status_and_model_from_db(
db_uri, db_name, model_dir, load_id)
if model1 is not None:
model1 = model1.to(device)
model2 = model2.to(device)
acmodels = model1, model2
current_cycle_count, _ = scheduling(status['num_frames'])
logger.info("Model successfully loaded\n")
logger.info("Loaded status: {}".format(status))
else:
# First one is pi_old, second one is pi_train
acmodels = [None, create_model(obs_space, envs)]
status = {"num_frames": 0, "update": 0}
current_cycle_count = 0
logger.info("Model successfully created\n")
logger.info("{}\n".format(acmodels[0]))
logger.info("Used device: {}\n".format(device))
# Define actor-critic algo
algo = create_algo(envs, *acmodels, preprocess_obss)
# Train model
num_frames = status["num_frames"]
total_start_time = time.time()
update = status["update"]
# current_cycle_count = 0
while num_frames < frames:
# Update model parameters
cycle_count, alpha = scheduling(num_frames)
if cycle_count != current_cycle_count:
current_cycle_count = cycle_count
switch_training_model(algo, obs_space, envs)
logger.info("Switched training model")
update_start_time = time.time()
logs = algo.update_parameters(alpha)
update_end_time = time.time()
num_frames += logs["num_frames"]
update += 1
# Print logs
if update % log_interval == 0:
fps = logs["num_frames"] / (update_end_time - update_start_time)
duration = int(time.time() - total_start_time)
return_per_episode = utils.synthesize(logs["return_per_episode"])
rreturn_per_episode = utils.synthesize(
logs["reshaped_return_per_episode"])
num_frames_per_episode = utils.synthesize(
logs["num_frames_per_episode"])
header = ["update", "frames", "FPS", "duration"]
data = [update, num_frames, fps, duration]
header += ["rreturn_" + key for key in rreturn_per_episode.keys()]
data += rreturn_per_episode.values()
header += [
"num_frames_" + key for key in num_frames_per_episode.keys()
]
data += num_frames_per_episode.values()
header += [
"entropy", "value_train", "value_old", "policy_loss_train",
"policy_loss_old", "value_loss_train", "value_loss_old"
]
data += [
logs["entropy"], logs["value_train"], logs["value_old"],
logs["policy_loss_train"], logs["policy_loss_old"],
logs["value_loss_train"], logs["value_loss_old"]
]
header += [
"grad_norm_train", "grad_norm_old", "alpha", "reg_loss_policy",
"reg_loss_value"
]
data += [
logs["grad_norm_train"], logs["grad_norm_old"], alpha,
logs["reg_loss_policy"], logs["reg_loss_value"]
]
logger.info(
"U {} | F {:06} | FPS {:04.0f} | D {} | rR:μσmM {:.2f} {:.2f} {:.2f} {:.2f} | F:μσmM {:.1f} {:.1f} {} {} | H {:.3f} | V:to {:.3f} {:.3f} "
.format(*data[:15]))
logger.info(
"pL:to {:.3f} {:.3f} | vL:to {:.3f} {:.3f} | ∇:to {:.3f} {:.3f} | alpha {:.2f} | rLpv {:.3f} {:.3f}\n"
.format(*data[15:]))
header += ["return_" + key for key in return_per_episode.keys()]
data += return_per_episode.values()
if status["num_frames"] == 0:
csv_writer.writerow(header)
csv_writer.writerow(data)
csv_file.flush()
for head, dat in zip(header, data):
_run.log_scalar(head, dat, num_frames)
status = {"num_frames": num_frames, "update": update}
# Save vocabulary and model
if save_interval > 0 and update % save_interval == 0:
preprocess_obss.vocab.save()
utils.save_model(algo.pi_old, algo.pi_train, model_dir)
logger.info("Model successfully saved")
utils.save_status(status, model_dir)
utils.save_model_to_db(algo.pi_old, algo.pi_train, model_dir, num_frames,
_run)
utils.save_status_to_db({
"num_frames": num_frames,
"update": update
}, model_dir, num_frames, _run)
import sys
import torch
from torch.utils.data import DataLoader
from utils import Model, DatasetPreparer, Data, seed
seed()
model_path = sys.argv[1]
model = Model().cuda()
model.load_state_dict(torch.load(model_path)['state_dict'])
dp = DatasetPreparer('Train.csv', 'audio_files')
train, test = dp.get_train_test()
test_loader = DataLoader(Data(test, data_augmentation=False, test=True), batch_size=32)
predictions = model.predict(test_loader)
submission = dp.submission(predictions, test)
submission.to_csv('submission.csv', index=False)
def main():
args = utils.parse_args(create_parser())
if args.logging_config is not None:
logging.config.dictConfig(utils.load_yaml(args.logging_config))
save_dir = pathlib.Path(args.save_dir)
if (not args.overwrite and
save_dir.exists() and utils.has_element(save_dir.glob("*.json"))):
raise FileExistsError(f"save directory ({save_dir}) is not empty")
shell = utils.ShellUtils()
shell.mkdir(save_dir, silent=True)
logger = logging.getLogger("train")
utils.seed(args.seed)
logger.info("loading data...")
load_fn = utils.chain_func(
lambda data: list(map(Dialog.from_json, data)),
utils.load_json
)
data_dir = pathlib.Path(args.data_dir)
train_data = load_fn(str(data_dir.joinpath("train.json")))
valid_data = load_fn(str(data_dir.joinpath("dev.json")))
processor = datasets.DialogProcessor(
sent_processor=datasets.SentProcessor(
bos=True,
eos=True,
lowercase=True,
tokenizer="space",
max_len=30
),
boc=True,
eoc=True,
state_order="randomized",
max_len=30
)
processor.prepare_vocabs(list(itertools.chain(train_data, valid_data)))
utils.save_pickle(processor, save_dir.joinpath("processor.pkl"))
logger.info("preparing model...")
utils.save_json(utils.load_yaml(args.model_path),
save_dir.joinpath("model.json"))
torchmodels.register_packages(models)
model_cls = torchmodels.create_model_cls(models, args.model_path)
model: models.AbstractTDA = model_cls(processor.vocabs)
model.reset_parameters()
utils.report_model(logger, model)
device = torch.device("cpu")
if args.gpu is not None:
device = torch.device(f"cuda:{args.gpu}")
model = model.to(device)
def create_scheduler(s):
return utils.PiecewiseScheduler([utils.Coordinate(*t) for t in eval(s)])
train_args = TrainArguments(
model=model,
train_data=tuple(train_data),
valid_data=tuple(valid_data),
processor=processor,
device=device,
save_dir=save_dir,
report_every=args.report_every,
batch_size=args.batch_size,
valid_batch_size=args.valid_batch_size,
optimizer=args.optimizer,
gradient_clip=args.gradient_clip,
l2norm_weight=args.l2norm_weight,
learning_rate=args.learning_rate,
num_epochs=args.epochs,
kld_schedule=(utils.ConstantScheduler(1.0)
if args.kld_schedule is None else
create_scheduler(args.kld_schedule)),
dropout_schedule=(utils.ConstantScheduler(1.0)
if args.dropout_schedule is None else
create_scheduler(args.dropout_schedule)),
validate_every=args.validate_every,
early_stop=args.early_stop,
early_stop_criterion=args.early_stop_criterion,
early_stop_patience=args.early_stop_patience,
disable_kl=args.disable_kl,
kl_mode=args.kl_mode,
save_every=args.save_every
)
utils.save_json(train_args.to_json(), save_dir.joinpath("args.json"))
record = train(train_args)
utils.save_json(record.to_json(), save_dir.joinpath("final-summary.json"))
# removing snow and other noise
if orig_w * orig_h <= 120:
continue
x_min = int(np.round(orig_x_min * scale_x))
y_min = int(np.round(orig_y_min * scale_y))
x_max = x_min + int(np.round(orig_w * scale_x))
y_max = y_min + int(np.round(orig_h * scale_y))
boxes.append([x_min, y_min, x_max, y_max])
classes.append(i + 1)
return obs_ss2, boxes, classes
seed(123)
environment = launch_env()
policy = PurePursuitPolicy(environment)
MAX_STEPS = 9000
while True:
obs = environment.reset()
environment.render(segment=True)
rewards = []
nb_of_steps = 0
while True:
action = policy.predict(np.array(obs))
def main(args):
device = torch.device(
"cpu" if args.gpu < 0 else "cuda:{}".format(args.gpu))
aggr_device = torch.device(
"cpu" if args.aggr_gpu < 0 else f"cuda:{args.aggr_gpu}")
# initial_emb_path = os.path.join("..", "embeddings", args.dataset,
# args.model if (args.model != "simple_sagn") else (args.model + "_" + args.weight_style),
# "initial_smoothed_features.pt")
total_best_val_accs = []
total_best_test_accs = []
total_val_accs = []
total_val_losses = []
total_preprocessing_times = []
total_train_times = []
total_inference_times = []
for i in range(args.num_runs):
print("-" * 100)
print(f"Run {i} start training")
seed(seed=args.seed + i)
if args.dataset == "ogbn-mag":
if args.fixed_subsets:
subset_list = read_subset_list(args.dataset,
args.example_subsets_path)
else:
g, _, _, _, _, _, _ = load_dataset(aggr_device, args)
subset_list = generate_subset_list(g, args.sample_size)
else:
subset_list = None
best_val_accs = []
best_test_accs = []
val_accs = []
val_losses = []
preprocessing_times = []
train_times = []
inference_times = []
for stage in range(len(args.epoch_setting)):
if args.warmup_stage > -1:
if stage <= args.warmup_stage:
probs_path = os.path.join(
args.probs_dir, args.dataset, args.model if
(args.weight_style == "attention") else
(args.model + "_" + args.weight_style),
f'use_labels_{args.use_labels}_use_feats_{not args.avoid_features}_K_{args.K}_label_K_{args.label_K}_probs_seed_{args.seed + i}_stage_{stage}.pt'
)
print(probs_path)
if os.path.exists(probs_path):
print(
f"bypass stage {stage} since warmup_stage is set and associated file exists."
)
continue
print("-" * 100)
print(f"Stage {stage} start training")
if stage > 0:
probs_path = os.path.join(
args.probs_dir, args.dataset, args.model if
(args.weight_style == "attention") else
(args.model + "_" + args.weight_style),
f'use_labels_{args.use_labels}_use_feats_{not args.avoid_features}_K_{args.K}_label_K_{args.label_K}_probs_seed_{args.seed + i}_stage_{stage - 1}.pt'
)
else:
probs_path = ''
with torch.no_grad():
data = prepare_data(device,
args,
probs_path,
stage,
load_embs=args.load_embs,
load_label_emb=args.load_label_emb,
subset_list=subset_list)
preprocessing_times.append(data[-1])
print(f"Preprocessing costs {(data[-1]):.4f} s")
best_val, best_test, probs, train_time, inference_time, val_acc, val_loss, attn_weights = run(
args, data, device, stage, subset_list=subset_list)
train_times.append(train_time)
inference_times.append(inference_time)
val_accs.append(val_acc)
val_losses.append(val_loss)
new_probs_path = os.path.join(
args.probs_dir, args.dataset, args.model if
(args.weight_style == "attention") else
(args.model + "_" + args.weight_style),
f'use_labels_{args.use_labels}_use_feats_{not args.avoid_features}_K_{args.K}_label_K_{args.label_K}_probs_seed_{args.seed + i}_stage_{stage}.pt'
)
if not os.path.exists(os.path.dirname(new_probs_path)):
os.makedirs(os.path.dirname(new_probs_path))
torch.save(probs, new_probs_path)
best_val_accs.append(best_val)
best_test_accs.append(best_test)
path = os.path.join(
"../converge_stats", args.dataset, args.model if
(args.weight_style == "attention") else
(args.model + "_" + args.weight_style),
f"use_labels_{args.use_labels}_use_feats_{not args.avoid_features}_K_{args.K}_label_K_{args.label_K}_seed_{args.seed + i}_stage_{stage}.csv"
)
if not os.path.exists(os.path.dirname(path)):
os.makedirs(os.path.dirname(path))
# print(val_acc)
df = pd.DataFrame()
df['epoch'] = np.arange(args.eval_every,
args.epoch_setting[stage] + 1,
args.eval_every)
df['val_acc'] = val_acc
df.to_csv(path)
fig_path = os.path.join(
"../converge_stats", args.dataset, args.model if
(args.weight_style == "attention") else
(args.model + "_" + args.weight_style),
f"use_labels_{args.use_labels}_use_feats_{not args.avoid_features}_K_{args.K}_label_K_{args.label_K}_seed_{args.seed + i}_stage_{stage}.png"
)
sns.set()
line_plt = sns.lineplot(data=df, x='epoch', y='val_acc')
line = line_plt.get_figure()
line.savefig(fig_path)
plt.close()
path = os.path.join(
"../converge_stats", args.dataset, args.model if
(args.weight_style == "attention") else
(args.model + "_" + args.weight_style),
f"val_loss_use_labels_{args.use_labels}_use_feats_{not args.avoid_features}_K_{args.K}_label_K_{args.label_K}_seed_{args.seed + i}_stage_{stage}.csv"
)
if not os.path.exists(os.path.dirname(path)):
os.makedirs(os.path.dirname(path))
# print(val_loss)
df = pd.DataFrame()
df['epoch'] = np.arange(args.eval_every,
args.epoch_setting[stage] + 1,
args.eval_every)
df['val_loss'] = val_loss
df.to_csv(path)
fig_path = os.path.join(
"../converge_stats", args.dataset, args.model if
(args.weight_style == "attention") else
(args.model + "_" + args.weight_style),
f"val_loss_use_labels_{args.use_labels}_use_feats_{not args.avoid_features}_K_{args.K}_label_K_{args.label_K}_seed_{args.seed + i}_stage_{stage}.png"
)
sns.set()
line_plt = sns.lineplot(data=df, x='epoch', y='val_loss')
line = line_plt.get_figure()
line.savefig(fig_path)
plt.close()
if (args.model in ["sagn", "plain_sagn"] and args.weight_style
== "attention") and (not args.avoid_features):
path = os.path.join(
"../attn_weights", args.dataset, args.model,
f"use_labels_{args.use_labels}_use_feats_{not args.avoid_features}_K_{args.K}_label_K_{args.label_K}_seed_{args.seed + i}_stage_{stage}.csv"
)
if not os.path.exists(os.path.dirname(path)):
os.makedirs(os.path.dirname(path))
df = pd.DataFrame(data=attn_weights.cpu().numpy())
df.to_csv(path)
fig_path = os.path.join(
"../attn_weights", args.dataset, args.model,
f"use_labels_{args.use_labels}_use_feats_{not args.avoid_features}_K_{args.K}_label_K_{args.label_K}_seed_{args.seed + i}_stage_{stage}.png"
)
sns.set()
heatmap_plt = sns.heatmap(df)
heatmap = heatmap_plt.get_figure()
heatmap.savefig(fig_path)
plt.close()
del data, df, probs, attn_weights
with torch.cuda.device(device):
torch.cuda.empty_cache()
total_best_val_accs.append(best_val_accs)
total_best_test_accs.append(best_test_accs)
total_val_accs.append(val_accs)
total_val_accs.append(val_losses)
total_preprocessing_times.append(preprocessing_times)
total_train_times.append(train_times)
total_inference_times.append(inference_times)
total_best_val_accs = np.array(total_best_val_accs)
total_best_test_accs = np.array(total_best_test_accs)
total_val_accs = np.array(total_val_accs)
total_preprocessing_times = np.array(total_preprocessing_times)
total_train_times = np.array(total_train_times, dtype=object)
total_inference_times = np.array(total_inference_times, dtype=object)
# print(total_preprocessing_times)
# print(total_train_times)
# print(total_inference_times)
for stage in range(len(args.epoch_setting)):
print(
f"Stage: {stage}, Val accuracy: {np.mean(total_best_val_accs[:, stage]):.4f}±"
f"{np.std(total_best_val_accs[:, stage]):.4f}")
print(
f"Stage: {stage}, Test accuracy: {np.mean(total_best_test_accs[:, stage]):.4f}±"
f"{np.std(total_best_test_accs[:, stage]):.4f}")
print(
f"Stage: {stage}, Preprocessing time: {np.mean(total_preprocessing_times[:, stage]):.4f}±"
f"{np.std(total_preprocessing_times[:, stage]):.4f}")
print(
f"Stage: {stage}, Training time: {np.hstack(total_train_times[:, stage]).mean():.4f}±"
f"{np.hstack(total_train_times[:, stage]).std():.4f}")
print(
f"Stage: {stage}, Inference time: {np.hstack(total_inference_times[:, stage]).mean():.4f}±"
f"{np.hstack(total_inference_times[:, stage]).std():.4f}")
def main():
global device, in_feats, n_classes, epsilon
argparser = argparse.ArgumentParser("AGDN on OGBN-Arxiv", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
argparser.add_argument("--cpu", action="store_true", help="CPU mode. This option overrides --gpu.")
argparser.add_argument("--gpu", type=int, default=0, help="GPU device ID.")
argparser.add_argument("--root", type=str, default="../dataset")
argparser.add_argument("--model", type=str, default="gat-ha")
argparser.add_argument("--seed", type=int, default=0, help="initial random seed.")
argparser.add_argument("--mode", type=str, default="test")
argparser.add_argument("--alpha",type=float,default=0.5,help="ratio of kd loss")
argparser.add_argument("--temp",type=float,default=1.0,help="temperature of kd")
argparser.add_argument("--n-runs", type=int, default=10)
argparser.add_argument("--n-epochs", type=int, default=2000)
argparser.add_argument(
"--use-labels", action="store_true", help="Use labels in the training set as input features."
)
argparser.add_argument("--mask-rate", type=float, default=0.5, help="mask rate")
argparser.add_argument("--n-label-iters", type=int, default=0, help="number of label iterations")
argparser.add_argument("--no-attn-dst", action="store_true", help="Don't use attn_dst.")
argparser.add_argument("--norm", type=str, help="Choices of normalization methods. values=['none','sym','avg']", default='none')
argparser.add_argument("--lr", type=float, default=0.002)
argparser.add_argument("--n-layers", type=int, default=3)
argparser.add_argument("--K", type=int, default=3)
argparser.add_argument("--n-heads", type=int, default=1)
argparser.add_argument("--n-hidden", type=int, default=256)
argparser.add_argument("--dropout", type=float, default=0.5)
argparser.add_argument("--input_drop", type=float, default=0.0)
argparser.add_argument("--edge_drop", type=float, default=0.0)
argparser.add_argument("--attn_drop", type=float, default=0.05)
argparser.add_argument("--wd", type=float, default=0)
argparser.add_argument("--log-every", type=int, default=20)
argparser.add_argument("--plot-curves", action="store_true")
argparser.add_argument("--use-linear", action="store_true", help="only useful for gcn model")
argparser.add_argument("--checkpoint-path", type=str, default="../checkpoint/")
argparser.add_argument("--output-path", type=str, default="../output/")
argparser.add_argument("--save-pred", action="store_true", help="save final predictions")
argparser.add_argument("--adjust-lr", action="store_true", help="adjust learning rate in first 50 iterations")
argparser.add_argument("--standard-loss", action="store_true")
args = argparser.parse_args()
print(f"args: {args}")
assert args.mode in ["teacher", "student", "test"]
if args.cpu:
device = torch.device("cpu")
else:
device = torch.device("cuda:%d" % args.gpu)
# load data
data = DglNodePropPredDataset(name="ogbn-arxiv", root=args.root)
evaluator = Evaluator(name="ogbn-arxiv")
splitted_idx = data.get_idx_split()
train_idx, val_idx, test_idx = splitted_idx["train"], splitted_idx["valid"], splitted_idx["test"]
graph, labels = data[0]
# add reverse edges
srcs, dsts = graph.all_edges()
graph.add_edges(dsts, srcs)
# add self-loop
print(f"Total edges before adding self-loop {graph.number_of_edges()}")
graph = graph.remove_self_loop().add_self_loop()
print(f"Total edges after adding self-loop {graph.number_of_edges()}")
in_feats = graph.ndata["feat"].shape[1]
n_classes = (labels.max() + 1).item()
# graph.create_format_()
train_idx = train_idx.to(device)
val_idx = val_idx.to(device)
test_idx = test_idx.to(device)
labels = labels.to(device)
graph = graph.to(device)
# run
val_accs = []
test_accs = []
for i in range(1, args.n_runs + 1):
seed(i + args.seed)
val_acc, test_acc = run(args, graph, labels, train_idx, val_idx, test_idx, evaluator, i)
val_accs.append(val_acc)
test_accs.append(test_acc)
print(f"Runned {args.n_runs} times")
print(f"Val Accs: {val_accs}")
print(f"Test Accs: {test_accs}")
print(f"Average val accuracy: {np.mean(val_accs)} ± {np.std(val_accs)}")
print(f"Average test accuracy: {np.mean(test_accs)} ± {np.std(test_accs)}")
print(f"Number of params: {count_parameters(args)}")
model = 'MiniGrid-ColoredKeysIPO-' + str(seed)
ipo_model = True
main([
'--algo', 'ipo', '--domain1', 'MiniGrid-ColoredKeysRed-v0',
'--domain2', 'MiniGrid-ColoredKeysGreen-v0', '--p1', '0.5',
'--model', model, '--save-interval', '1', '--frames',
str(num_frames_total), '--seed',
str(seed), '--procs',
str(48), '--lr',
str(0.0005)
])
else:
raise ValueError("No such method supported")
# Set seed for all randomness sources
utils.seed(seed)
# Load environments
envs = []
for i in range(procs):
env = utils.make_env(env_eval,
seed + 100 * i) # Different envs from training
envs.append(env)
env = ParallelEnv(envs)
print("Environments loaded\n")
# Load agents
model_dir = utils.get_model_dir(model)
agent = utils.Agent(env.observation_space, env.action_space, model_dir,
ipo_model, device, argmax, procs)
