# 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)