def main(): p = class_parser.Parser() total_seeds = len(p.parse_known_args()[0].seed) rank = p.parse_known_args()[0].rank all_args = vars(p.parse_known_args()[0]) print("All args = ", all_args) args = utils.get_run(vars(p.parse_known_args()[0]), rank) utils.set_seed(args['seed']) my_experiment = experiment(args['name'], args, "../results/", commit_changes=False, rank=0, seed=1) writer = SummaryWriter(my_experiment.path + "tensorboard") logger = logging.getLogger('experiment') # Using first 963 classes of the omniglot as the meta-training set args['classes'] = list(range(963)) args['traj_classes'] = list(range(int(963/2), 963)) dataset = df.DatasetFactory.get_dataset(args['dataset'], background=True, train=True,path=args["path"], all=True) dataset_test = df.DatasetFactory.get_dataset(args['dataset'], background=True, train=False, path=args["path"], all=True) # Iterators used for evaluation iterator_test = torch.utils.data.DataLoader(dataset_test, batch_size=5, shuffle=True, num_workers=1) iterator_train = torch.utils.data.DataLoader(dataset, batch_size=5, shuffle=True, num_workers=1) sampler = ts.SamplerFactory.get_sampler(args['dataset'], args['classes'], dataset, dataset_test) config = mf.ModelFactory.get_model("na", args['dataset'], output_dimension=1000) gpu_to_use = rank % args["gpus"] if torch.cuda.is_available(): device = torch.device('cuda:' + str(gpu_to_use)) logger.info("Using gpu : %s", 'cuda:' + str(gpu_to_use)) else: device = torch.device('cpu') maml = MetaLearingClassification(args, config).to(device) for step in range(args['steps']): t1 = np.random.choice(args['traj_classes'], args['tasks'], replace=False) d_traj_iterators = [] for t in t1: d_traj_iterators.append(sampler.sample_task([t])) d_rand_iterator = sampler.get_complete_iterator() x_spt, y_spt, x_qry, y_qry = maml.sample_training_data(d_traj_iterators, d_rand_iterator, steps=args['update_step'], reset=not args['no_reset']) if torch.cuda.is_available(): x_spt, y_spt, x_qry, y_qry = x_spt.to(device), y_spt.to(device), x_qry.to(device), y_qry.to(device) accs, loss = maml(x_spt, y_spt, x_qry, y_qry)
from experiment.experiment import experiment from utils import utils from torch import nn from model import lstm from copy import deepcopy gamma = 0.9 logger = logging.getLogger('experiment') p = reg_parser.Parser() total_seeds = len(p.parse_known_args()[0].seed) rank = p.parse_known_args()[0].run all_args = vars(p.parse_known_args()[0]) args = utils.get_run(all_args, rank) my_experiment = experiment(args["name"], args, args["output_dir"], sql=True, run=int(rank / total_seeds), seed=total_seeds) my_experiment.results["all_args"] = all_args my_experiment.make_table("error_table", { "run": 0, "step": 0, "error": 0.0 }, ("run", "step")) my_experiment.make_table(
def main(): p = reg_parser.Parser() total_seeds = len(p.parse_known_args()[0].seed) rank = p.parse_known_args()[0].rank all_args = vars(p.parse_known_args()[0]) args = utils.get_run(all_args, rank) my_experiment = experiment(args["name"], args, args["output_dir"], commit_changes=False, rank=int(rank / total_seeds), seed=total_seeds) my_experiment.results["all_args"] = all_args logger = logging.getLogger('experiment') gradient_error_list = [] gradient_alignment_list = [] for seed in range(args["runs"]): utils.set_seed(args["seed"] + seed + seed*args["seed"]) n = Recurrent_Network(50, args['columns'], args["width"], args["sparsity"]) error_grad_mc = 0 rnn_state = torch.zeros(args['columns']) n.reset_TH() for ind in range(50): x = torch.bernoulli(torch.zeros(1, 50) + 0.5) _, _, grads = n.forward(x, rnn_state, grad=True, retain_graph=False, bptt=False) value_prediction, rnn_state, _ = n.forward(x, rnn_state, grad=False, retain_graph=False, bptt=True) n.update_TH(grads) target_random = random.random() * 100 - 50 real_error = (0.5) * (target_random - value_prediction) ** 2 error_grad_mc += real_error n.accumulate_gradients(target_random, value_prediction, hidden_state=rnn_state) grads = torch.autograd.grad(error_grad_mc, n.parameters()) counter = 0 total_sum = 0 positive_sum = 0 dif = 0 for named, param in n.named_parameters(): # if "prediction" in named: # counter+=1 # continue # print(named) # print(grads[counter], n.grads[named]) dif += torch.abs(n.grads[named] - grads[counter]).sum() positive = ((n.grads[named] * grads[counter]) > 1e-10).float().sum() total = positive + ((n.grads[named] * grads[counter]) < - 1e-10).float().sum() total_sum += total positive_sum += positive counter += 1 logger.error("Difference = %s", (float(dif) / total_sum).item()) gradient_error_list.append( (float(dif) / total_sum).item()) gradient_alignment_list.append(str(float(positive_sum) / float(total_sum))) logger.error("Grad alignment %s", str(float(positive_sum) / float(total_sum))) my_experiment.add_result("abs_error", str(gradient_error_list)) my_experiment.add_result("alignment", str(gradient_alignment_list)) my_experiment.store_json()
def main(): p = class_parser.Parser() total_seeds = len(p.parse_known_args()[0].seed) rank = p.parse_known_args()[0].rank all_args = vars(p.parse_known_args()[0]) print("All args = ", all_args) args = utils.get_run(vars(p.parse_known_args()[0]), rank) utils.set_seed(args["seed"]) if args["log_root"]: log_root = osp.join("./results", args["log_root"]) + "/" else: log_root = osp.join("./results/") my_experiment = experiment( args["name"], args, log_root, commit_changes=False, rank=0, seed=args["seed"], ) writer = SummaryWriter(my_experiment.path + "tensorboard") logger = logging.getLogger("experiment") # Using first 963 classes of the omniglot as the meta-training set # args["classes"] = list(range(963)) args["classes"] = list(range(args["num_classes"])) print("Using classes:", args["num_classes"]) # logger.info("Using classes:", str(args["num_classes"])) # args["traj_classes"] = list(range(int(963 / 2), 963)) if torch.cuda.is_available(): device = torch.device("cuda") use_cuda = True else: device = torch.device("cpu") use_cuda = False dataset_spt = df.DatasetFactory.get_dataset( args["dataset"], background=True, train=True, path=args["path"], # all=True, # all=False, all=args["all"], prefetch_gpu=args["prefetch_gpu"], device=device, resize=args["resize"], augment=args["augment_spt"], ) dataset_qry = df.DatasetFactory.get_dataset( args["dataset"], background=True, train=True, path=args["path"], # all=True, # all=False, all=args["all"], prefetch_gpu=args["prefetch_gpu"], device=device, resize=args["resize"], augment=args["augment_qry"], ) dataset_test = df.DatasetFactory.get_dataset( args["dataset"], background=True, train=False, path=args["path"], # all=True, # all=False, all=args["all"], resize=args["resize"], # augment=args["augment"], ) logger.info( f"Support size: {len(dataset_spt)}, Query size: {len(dataset_qry)}, test size: {len(dataset_test)}" ) # print(f"Support size: {len(dataset_spt)}, Query size: {len(dataset_qry)}, test size: {len(dataset_test)}") pin_memory = use_cuda if args["prefetch_gpu"]: num_workers = 0 pin_memory = False else: num_workers = args["num_workers"] # Iterators used for evaluation iterator_test = torch.utils.data.DataLoader( dataset_test, batch_size=5, shuffle=True, num_workers=0, # pin_memory=pin_memory, ) iterator_train = torch.utils.data.DataLoader( dataset_spt, batch_size=5, shuffle=True, num_workers=0, # pin_memory=pin_memory, ) logger.info("Support sampler:") sampler_spt = ts.SamplerFactory.get_sampler( args["dataset"], args["classes"], dataset_spt, dataset_test, prefetch_gpu=args["prefetch_gpu"], use_cuda=use_cuda, num_workers=0, ) logger.info("Query sampler:") sampler_qry = ts.SamplerFactory.get_sampler( args["dataset"], args["classes"], dataset_qry, dataset_test, prefetch_gpu=args["prefetch_gpu"], use_cuda=use_cuda, num_workers=0, ) config = mf.ModelFactory.get_model( "na", args["dataset"], output_dimension=1000, resize=args["resize"], ) gpu_to_use = rank % args["gpus"] if torch.cuda.is_available(): device = torch.device("cuda:" + str(gpu_to_use)) logger.info("Using gpu : %s", "cuda:" + str(gpu_to_use)) else: device = torch.device("cpu") maml = MetaLearingClassification(args, config).to(device) for step in range(args["steps"]): t1 = np.random.choice(args["classes"], args["tasks"], replace=False) d_traj_iterators_spt = [] d_traj_iterators_qry = [] for t in t1: d_traj_iterators_spt.append(sampler_spt.sample_task([t])) d_traj_iterators_qry.append(sampler_qry.sample_task([t])) d_rand_iterator = sampler_spt.get_complete_iterator() x_spt, y_spt, x_qry, y_qry = maml.sample_training_data_paper( d_traj_iterators_spt, d_traj_iterators_qry, d_rand_iterator, steps=args["update_step"], reset=not args["no_reset"], ) if torch.cuda.is_available(): x_spt, y_spt, x_qry, y_qry = ( x_spt.to(device), y_spt.to(device), x_qry.to(device), y_qry.to(device), ) # accs, loss = maml(x_spt, y_spt, x_qry, y_qry) # Evaluation during training for sanity checks if step % 40 == 5: writer.add_scalar("/metatrain/train/accuracy", accs[-1], step) writer.add_scalar("/metatrain/train/loss", loss[-1], step) writer.add_scalar("/metatrain/train/accuracy0", accs[0], step) writer.add_scalar("/metatrain/train/loss0", loss[0], step) logger.info("step: %d \t training acc %s", step, str(accs)) logger.info("step: %d \t training loss %s", step, str(loss)) # Currently useless if (step % 300 == 3) or ((step + 1) == args["steps"]): torch.save(maml.net, my_experiment.path + "learner.model")
def main(): p = reg_parser.Parser() total_seeds = len(p.parse_known_args()[0].seed) run = p.parse_known_args()[0].run all_args = vars(p.parse_known_args()[0]) args = utils.get_run(all_args, run) my_experiment = experiment(args["name"], args, args["output_dir"], sql=True, run=int(run / total_seeds), seed=total_seeds) my_experiment.results["all_args"] = all_args my_experiment.make_table("metrics", { "run": 0, "meta_loss": 0.0, "step": 0 }, ("run", "step")) metrics_keys = ["run", "meta_loss", "step"] logger = logging.getLogger('experiment') tasks = list(range(400)) sampler = ts.SamplerFactory.get_sampler("Sin", tasks, None, capacity=args["capacity"] + 1) model_config = mf.ModelFactory.get_model(args["model"], "Sin", input_dimension=args["capacity"] + 1, output_dimension=1, width=args["width"], cols=args["cols"]) gpu_to_use = run % args["gpus"] if torch.cuda.is_available(): device = torch.device('cuda:' + str(gpu_to_use)) logger.info("Using gpu : %s", 'cuda:' + str(gpu_to_use)) else: device = torch.device('cpu') if args.get('update_rule') == "RTRL": logger.info("Columnar Net based gradient approximation...") metalearner = MetaLearnerRegressionCol(args, model_config, device=device).to(device) else: logger.info("BPTT update rule...") metalearner = MetaLearnerRegression(args, model_config, device=device).to(device) tmp = filter(lambda x: x.requires_grad, metalearner.parameters()) num = sum(map(lambda x: np.prod(x.shape), tmp)) logger.info('Total trainable tensors: %d', num) running_meta_loss = 0 adaptation_loss = 0 loss_history = [] metrics_list = [] metrics_keys = ["run", "meta_loss", "step"] adaptation_loss_history = [] adaptation_running_loss_history = [] meta_steps_counter = 0 LOG_INTERVAL = 2 for step in range(args["epoch"]): if step % LOG_INTERVAL == 0: logger.debug("####\t STEP %d \t####", step) net = metalearner.net meta_steps_counter += 1 t1 = np.random.choice(tasks, args["tasks"], replace=False) iterators = [] for t in t1: iterators.append(sampler.sample_task([t])) x_traj_meta, y_traj_meta, x_rand_meta, y_rand_meta = utils.construct_set( iterators, sampler, steps=1) x_traj_meta, x_rand_meta, y_traj_meta, y_rand_meta = x_traj_meta.view( -1, 51), x_rand_meta.view(-1, 51), y_traj_meta.view( -1, 2), y_rand_meta.view(-1, 2) if torch.cuda.is_available(): x_traj_meta, y_traj_meta, x_rand_meta, y_rand_meta = x_traj_meta.to( device), y_traj_meta.to(device), x_rand_meta.to( device), y_rand_meta.to(device) meta_loss = metalearner(x_traj_meta, y_traj_meta, x_rand_meta, y_rand_meta) loss_history.append(meta_loss[-1].detach().cpu().item()) running_meta_loss = running_meta_loss * 0.97 + 0.03 * meta_loss[ -1].detach().cpu() running_meta_loss_fixed = running_meta_loss / (1 - (0.97** (meta_steps_counter))) metrics_list.append((run, running_meta_loss_fixed.item(), step)) if step % LOG_INTERVAL == 0: if running_meta_loss > 0: logger.info("Running meta loss = %f", running_meta_loss_fixed.item()) with torch.no_grad(): t1 = np.random.choice(tasks, args["tasks"], replace=False) iterators = [] for t in t1: iterators.append(sampler.sample_task([t])) x_traj, y_traj, x_rand, y_rand = utils.construct_set(iterators, sampler, steps=1) x_traj, x_rand, y_traj, y_rand = x_traj.view( -1, 51), x_rand.view(-1, 51), y_traj.view(-1, 2), y_rand.view(-1, 2) if torch.cuda.is_available(): x_traj, y_traj, x_rand, y_rand = x_traj.to( device), y_traj.to(device), x_rand.to( device), y_rand.to(device) logits_select = [] for i in range(len(x_rand)): l, _, _ = net.forward_col(x_rand[i], vars=None, grad=False) logits_select.append(l) logits = torch.stack(logits_select).unsqueeze(1) current_adaptation_loss = F.mse_loss(logits, y_rand[:, 0].unsqueeze(1)) adaptation_loss_history.append( current_adaptation_loss.detach().item()) adaptation_loss = adaptation_loss * 0.97 + current_adaptation_loss.detach( ).cpu().item() * 0.03 adaptation_loss_fixed = adaptation_loss / (1 - (0.97**(step + 1))) adaptation_running_loss_history.append(adaptation_loss_fixed) logger.info("Adaptation loss = %f", current_adaptation_loss) if step % LOG_INTERVAL == 0: logger.info("Running adaptation loss = %f", adaptation_loss_fixed) if (step + 1) % (LOG_INTERVAL * 500) == 0: if not args["no_save"]: torch.save(metalearner.net, my_experiment.path + "net.model") dict_names = {} for (name, param) in metalearner.net.named_parameters(): dict_names[name] = param.adaptation my_experiment.insert_values("metrics", metrics_keys, metrics_list) metrics_list = [] my_experiment.add_result("Layers meta values", dict_names) my_experiment.add_result("Meta loss", loss_history) my_experiment.add_result("Adaptation loss", adaptation_loss_history) my_experiment.add_result("Running adaption loss", adaptation_running_loss_history) my_experiment.store_json()
def main(): p = reg_parser.Parser() total_seeds = len(p.parse_known_args()[0].seed) rank = p.parse_known_args()[0].rank all_args = vars(p.parse_known_args()[0]) args = utils.get_run(all_args, rank) my_experiment = exp.experiment(args["name"], args, args["output_dir"], commit_changes=False, rank=int(rank / total_seeds), seed=total_seeds) my_experiment.results["all_args"] = all_args param_dict = {} results_dir = args["path"] for experiment in os.listdir(results_dir): if "DS_St" not in experiment: # print(experiment) for run in os.listdir(os.path.join(results_dir, experiment)): if "DS_St" not in run: print( os.path.join(results_dir, experiment, run, "metadata.json")) try: path = os.path.join(results_dir, experiment, run, "metadata.json") with open(path) as json_file: data_temp = json.load(json_file) experiment_name = str(data_temp['params']) param_dict[experiment_name] = data_temp['params'] if experiment_name in all_experiments: all_experiments[experiment_name].append( data_temp['results'][args["metric"]]) # print(data_temp['results']['Real_Error_list']) else: all_experiments[experiment_name] = [ data_temp['results'][args["metric"]] ] # print(data_temp['results']['Real_Error_list']) except: pass sns.set(style="whitegrid") sns.set_context("paper", font_scale=0.4, rc={"lines.linewidth": 1.0}) truncation_dict = [] for experiment_name in all_experiments: experiment_params = param_dict[experiment_name] temp = experiment_params["truncation"] if temp not in truncation_dict: truncation_dict.append(temp) for a in truncation_dict: counter = 0 x = [] y = [] error = [] for experiment_name in all_experiments: experiment_params = param_dict[experiment_name] if experiment_params["width"] == 50 and experiment_params[ "columns"] == 20 and experiment_params["truncation"] == a: for list_of_vals in all_experiments[experiment_name]: # print(list_of_vals) # print(d.strip("[").strip("]").strip("\,")) y_pred = ast.literal_eval(list_of_vals) y_pred = [float(x) for x in y_pred] y_pred_mean = np.mean(y_pred) y_pred_error = np.std(y_pred) / np.sqrt(len(y_pred)) x_cur = experiment_params["sparsity"] x.append(x_cur) y.append(y_pred_mean) # print(x) error.append(y_pred_error) # d_sparse = [] # running_sum = y_pred[0] # for number, value_in in enumerate(y_pred): # running_sum = running_sum * 0.96 + value_in * 0.04 # if number % 50 == 0: # d_sparse.append(running_sum) # print(d_new) x = np.array(x) if args["log"]: x = np.log10(x) y = np.array(y) arg_sort = np.argsort(x) x = np.array([x[p] for p in arg_sort]) y = np.array([y[p] for p in arg_sort]) error = np.array([error[p] for p in arg_sort]) plt.fill_between(x, y - error, y + error, alpha=0.4) plt.plot(x, y) plt.ylim(0.4, 1) # plt.xlim(0, 10) plt.tight_layout() print(my_experiment.path + "result.pdf") plt.legend(truncation_dict) plt.savefig(my_experiment.path + "result.pdf", format="pdf")
def main(): p = reg_parser.Parser() total_seeds = len(p.parse_known_args()[0].seed) rank = p.parse_known_args()[0].rank all_args = vars(p.parse_known_args()[0]) args = utils.get_run(vars(p.parse_known_args()[0]), rank) utils.set_seed(args["seed"]) my_experiment = experiment(args["name"], args, "../results/", commit_changes=False, rank=int(rank / total_seeds), seed=total_seeds) my_experiment.results["all_args"] = all_args writer = SummaryWriter(my_experiment.path + "tensorboard") logger = logging.getLogger('experiment') pprint(args) tasks = list(range(400)) sampler = ts.SamplerFactory.get_sampler("Sin", tasks, None, capacity=args["capacity"] + 1) model_config = mf.ModelFactory.get_model(args["model"], "Sin", input_dimension=args["capacity"] + 1, output_dimension=1, width=args["width"]) context_backbone_config = None gpu_to_use = rank % args["gpus"] if torch.cuda.is_available(): device = torch.device('cuda:' + str(gpu_to_use)) logger.info("Using gpu : %s", 'cuda:' + str(gpu_to_use)) else: device = torch.device('cpu') metalearner = MetaLearnerRegression(args, model_config, context_backbone_config).to(device) tmp = filter(lambda x: x.requires_grad, metalearner.parameters()) num = sum(map(lambda x: np.prod(x.shape), tmp)) logger.info('Total trainable tensors: %d', num) # running_meta_loss = 0 adaptation_loss = 0 loss_history = [] adaptation_loss_history = [] adaptation_running_loss_history = [] meta_steps_counter = 0 LOG_INTERVAL = 50 for step in range(args["epoch"]): if step % LOG_INTERVAL == 0: logger.debug("####\t STEP %d \t####", step) net = metalearner.net meta_steps_counter += 1 t1 = np.random.choice(tasks, args["tasks"], replace=False) iterators = [] for t in t1: iterators.append(sampler.sample_task([t])) x_traj_meta, y_traj_meta, x_rand_meta, y_rand_meta = utils.construct_set( iterators, sampler, steps=args["update_step"]) x_traj_meta, y_traj_meta = x_traj_meta.view(-1, 1, 51), y_traj_meta.view( -1, 1, 2) if torch.cuda.is_available(): x_traj_meta, y_traj_meta, x_rand_meta, y_rand_meta = x_traj_meta.to( device), y_traj_meta.to(device), x_rand_meta.to( device), y_rand_meta.to(device) meta_loss = metalearner(x_traj_meta, y_traj_meta, x_rand_meta, y_rand_meta) loss_history.append(meta_loss[-1].detach().cpu().item()) running_meta_loss = running_meta_loss * 0.97 + 0.03 * meta_loss[ -1].detach().cpu() running_meta_loss_fixed = running_meta_loss / (1 - (0.97** (meta_steps_counter))) writer.add_scalar('/metatrain/train/accuracy', meta_loss[-1].detach().cpu(), meta_steps_counter) writer.add_scalar('/metatrain/train/runningaccuracy', running_meta_loss_fixed, meta_steps_counter) if step % LOG_INTERVAL == 0: if running_meta_loss > 0: logger.info("Running meta loss = %f", running_meta_loss_fixed.item()) with torch.no_grad(): t1 = np.random.choice(tasks, args["tasks"], replace=False) iterators = [] for t in t1: iterators.append(sampler.sample_task([t])) x_traj, y_traj, x_rand, y_rand = utils.construct_set( iterators, sampler, steps=args["update_step"]) x_traj, y_traj = x_traj.view(-1, 1, 51), y_traj.view(-1, 1, 2) if torch.cuda.is_available(): x_traj, y_traj, x_rand, y_rand = x_traj.to( device), y_traj.to(device), x_rand.to( device), y_rand.to(device) logits = net(x_rand[0], vars=None) logits_select = [] assert y_rand[0, :, 1].sum() == 0 for no, val in enumerate(y_rand[0, :, 1].long()): logits_select.append(logits[no, val]) logits = torch.stack(logits_select).unsqueeze(1) current_adaptation_loss = F.mse_loss( logits, y_rand[0, :, 0].unsqueeze(1)) adaptation_loss_history.append( current_adaptation_loss.detach().item()) adaptation_loss = adaptation_loss * 0.97 + current_adaptation_loss.detach( ).cpu().item() * 0.03 adaptation_loss_fixed = adaptation_loss / (1 - (0.97**(step + 1))) adaptation_running_loss_history.append(adaptation_loss_fixed) logger.info("Adaptation loss = %f", current_adaptation_loss) if step % LOG_INTERVAL == 0: logger.info("Running adaptation loss = %f", adaptation_loss_fixed) writer.add_scalar('/learn/test/adaptation_loss', current_adaptation_loss, step) if (step + 1) % (LOG_INTERVAL * 500) == 0: if not args["no_save"]: torch.save(metalearner.net, my_experiment.path + "net.model") dict_names = {} for (name, param) in metalearner.net.named_parameters(): dict_names[name] = param.adaptation my_experiment.add_result("Layers meta values", dict_names) my_experiment.add_result("Meta loss", loss_history) my_experiment.add_result("Adaptation loss", adaptation_loss_history) my_experiment.add_result("Running adaption loss", adaptation_running_loss_history) my_experiment.store_json()