X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=main.py;h=324aeba663a5b4c7453ce03ff5deb7062e1da7e3;hb=fd2166de6350fc3f2b3fdb90849115574e3ae843;hp=38dccb9f8eea57437ce7574d4f87208ab0077b38;hpb=87214829798bca7e3eb853df4a27bcb918bb9f67;p=picoclvr.git diff --git a/main.py b/main.py index 38dccb9..324aeba 100755 --- a/main.py +++ b/main.py @@ -32,12 +32,15 @@ parser = argparse.ArgumentParser( ) parser.add_argument( - "--task", type=str, default="picoclvr", help="picoclvr, mnist, maze, snake, stack" + "--task", + type=str, + default="picoclvr", + help="picoclvr, mnist, maze, snake, stack, expr", ) parser.add_argument("--log_filename", type=str, default="train.log", help=" ") -parser.add_argument("--result_dir", type=str, default="results_default") +parser.add_argument("--result_dir", type=str, default=None) parser.add_argument("--seed", type=int, default=0) @@ -123,22 +126,8 @@ args = parser.parse_args() assert args.picocvlr_prune_properties in {"none", "train+eval", "eval"} -try: - os.mkdir(args.result_dir) -except FileExistsError: - if not args.overwrite_results: - print(f"result directory {args.result_dir} already exists") - exit(1) - -log_file = open(os.path.join(args.result_dir, args.log_filename), "a") - -if args.seed >= 0: - # torch.backends.cudnn.deterministic = True - # torch.backends.cudnn.benchmark = False - # torch.use_deterministic_algorithms(True) - torch.manual_seed(args.seed) - if torch.cuda.is_available(): - torch.cuda.manual_seed_all(args.seed) +if args.result_dir is None: + args.result_dir = f"results_{args.task}" ###################################################################### @@ -173,6 +162,12 @@ default_args = { "nb_train_samples": 100000, "nb_test_samples": 1000, }, + "expr": { + "nb_epochs": 5, + "batch_size": 25, + "nb_train_samples": 100000, + "nb_test_samples": 1000, + }, } if args.task in default_args: @@ -182,6 +177,25 @@ if args.task in default_args: ###################################################################### +try: + os.mkdir(args.result_dir) +except FileExistsError: + if not args.overwrite_results: + print(f"result directory {args.result_dir} already exists") + exit(1) + +log_file = open(os.path.join(args.result_dir, args.log_filename), "a") + +if args.seed >= 0: + # torch.backends.cudnn.deterministic = True + # torch.backends.cudnn.benchmark = False + # torch.use_deterministic_algorithms(True) + torch.manual_seed(args.seed) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(args.seed) + +###################################################################### + def log_string(s): t = time.strftime("%Y%m%d-%H:%M:%S ", time.localtime()) @@ -212,9 +226,8 @@ def masked_inplace_autoregression( progress_bar_desc="autoregression", device=torch.device("cpu"), ): - # p = logits.softmax(1) - # entropy[:,s]= p.xlogy(p).sum(1) / math.log(2) batches = zip(input.split(batch_size), ar_mask.split(batch_size)) + if progress_bar_desc is not None: batches = tqdm.tqdm( batches, @@ -222,6 +235,7 @@ def masked_inplace_autoregression( desc=progress_bar_desc, total=input.size(0) // batch_size, ) + for input, ar_mask in batches: i = (ar_mask.sum(0) > 0).nonzero() if i.min() > 0: @@ -704,14 +718,14 @@ class TaskMaze(Task): model, "train", nb_to_use=1000 ) log_string( - f"accuracy_train nb_total {train_nb_total} nb_correct {train_nb_correct} accuracy {(100.0*train_nb_correct)/train_nb_total:.02f}%" + f"accuracy_train {n_epoch} nb_total {train_nb_total} nb_correct {train_nb_correct} accuracy {(100.0*train_nb_correct)/train_nb_total:.02f}%" ) test_nb_total, test_nb_correct, count = self.compute_error( model, "test", nb_to_use=1000 ) log_string( - f"accuracy_test nb_total {test_nb_total} nb_correct {test_nb_correct} accuracy {(100.0*test_nb_correct)/test_nb_total:.02f}%" + f"accuracy_test {n_epoch} nb_total {test_nb_total} nb_correct {test_nb_correct} accuracy {(100.0*test_nb_correct)/test_nb_total:.02f}%" ) if count is not None: @@ -857,7 +871,7 @@ class TaskSnake(Task): ) log_string( - f"accuracy_test nb_total {test_nb_total} nb_correct {test_nb_correct} accuracy {(100.0*test_nb_correct)/test_nb_total:.02f}%" + f"accuracy_test {n_epoch} nb_total {test_nb_total} nb_correct {test_nb_correct} accuracy {(100.0*test_nb_correct)/test_nb_total:.02f}%" ) model.train(t) @@ -914,12 +928,10 @@ class TaskStack(Task): self.device, ) - mask = self.test_input.clone() - stack.remove_popped_values(mask, self.nb_stacks, self.nb_digits) - mask = mask != self.test_input - counts = self.test_stack_counts.flatten()[mask.flatten()] + i = torch.logical_and(self.test_input % 2 == 1, self.test_input < 2 * nb_stacks) + counts = self.test_stack_counts.flatten()[i.flatten()] counts = F.one_hot(counts).sum(0) - log_string(f"stack_count {counts}") + log_string(f"test_pop_stack_counts {counts}") self.nb_codes = max(self.train_input.max(), self.test_input.max()) + 1 @@ -964,13 +976,12 @@ class TaskStack(Task): test_nb_total, test_nb_correct = compute_nb_correct(self.test_input[:1000]) log_string( - f"accuracy_test nb_total {test_nb_total} nb_correct {test_nb_correct} accuracy {(100.0*test_nb_correct)/test_nb_total:.02f}%" + f"accuracy_test {n_epoch} nb_total {test_nb_total} nb_correct {test_nb_correct} accuracy {(100.0*test_nb_correct)/test_nb_total:.02f}%" ) - #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - l = 50 - l = l - l % (1 + self.nb_digits) - input = self.test_input[:10, :l] + ############################################################## + # Log a few generated sequences + input = self.test_input[:10, : 12 * (1 + self.nb_digits)] result = input.clone() stack.remove_popped_values(result, self.nb_stacks, self.nb_digits) ar_mask = (result != input).long() @@ -985,7 +996,119 @@ class TaskStack(Task): log_string( f"test_after {stack.seq_to_str(result[n],nb_stacks=self.nb_stacks,nb_digits=self.nb_digits)}" ) - #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ############################################################## + + model.train(t) + + +###################################################################### + + +import expr + + +class TaskExpr(Task): + def __init__( + self, + nb_train_samples, + nb_test_samples, + batch_size, + device=torch.device("cpu"), + ): + self.batch_size = batch_size + self.device = device + + train_sequences = expr.generate_sequences(nb_train_samples) + test_sequences = expr.generate_sequences(nb_test_samples) + self.char2id = dict( + [ + (c, n) + for n, c in enumerate(set("#"+"".join(train_sequences + test_sequences))) + ] + ) + self.id2char = dict([(n, c) for c, n in self.char2id.items()]) + len_max = max([len(x) for x in train_sequences + test_sequences]) + self.train_input = torch.cat( + [ + torch.tensor( + [ + [self.char2id[c] for c in s + "#" * (len_max - len(s))] + for s in train_sequences + ] + ) + ], + 0, + ).to(device) + self.test_input = torch.cat( + [ + torch.tensor( + [ + [self.char2id[c] for c in s + "#" * (len_max - len(s))] + for s in test_sequences + ] + ) + ], + 0, + ).to(device) + self.nb_codes = max(self.train_input.max(), self.test_input.max()) + 1 + + def batches(self, split="train", nb_to_use=-1, desc=None): + assert split in {"train", "test"} + input = self.train_input if split == "train" else self.test_input + if nb_to_use > 0: + input = input[:nb_to_use] + if desc is None: + desc = f"epoch-{split}" + for batch in tqdm.tqdm( + input.split(self.batch_size), dynamic_ncols=True, desc=desc + ): + yield batch + + def vocabulary_size(self): + return self.nb_codes + + def produce_results(self, n_epoch, model): + with torch.autograd.no_grad(): + t = model.training + model.eval() + + def compute_nb_correct(input): + result = input.clone() + space = self.char2id["#"] + ar_mask = (result == space).long().cumsum(dim=1).clamp(max=1) + result = (1 - ar_mask) * result + space * ar_mask + masked_inplace_autoregression( + model, self.batch_size, result, ar_mask, device=self.device + ) + + nb_total = ar_mask.sum() + nb_correct = ((input == result).long() * ar_mask).sum() + + return nb_total, nb_correct + + test_nb_total, test_nb_correct = compute_nb_correct(self.test_input[:1000]) + + log_string( + f"accuracy_test {n_epoch} nb_total {test_nb_total} nb_correct {test_nb_correct} accuracy {(100.0*test_nb_correct)/test_nb_total:.02f}%" + ) + + ############################################################## + # Log a few generated sequences + input = self.test_input[:10] + result = input.clone() + space = self.char2id["#"] + ar_mask = (result == space).long().cumsum(dim=1).clamp(max=1) + result = (1 - ar_mask) * result + space * ar_mask + for n in range(result.size(0)): + s = "".join([self.id2char[k.item()] for k in result[n]]) + log_string(f"test_before {s}") + masked_inplace_autoregression( + model, self.batch_size, result, ar_mask, device=self.device + ) + for n in range(result.size(0)): + s = "".join([self.id2char[k.item()] for k in result[n]]) + log_string(f"test_after {s}") + ############################################################## model.train(t) @@ -1066,6 +1189,14 @@ elif args.task == "stack": device=device, ) +elif args.task == "expr": + task = TaskExpr( + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.batch_size, + device=device, + ) + else: raise ValueError(f"Unknown task {args.task}")