X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=main.py;h=9437136ce1a45b066d6884e205540083bfb4d2d6;hb=HEAD;hp=acecfdd311048fdbc1aedc49becae0b703783fbc;hpb=b003cc9f89b7c3356f7d1e6c0c10b3dea249ef96;p=picoclvr.git diff --git a/main.py b/main.py index acecfdd..3ff64b7 100755 --- a/main.py +++ b/main.py @@ -5,16 +5,14 @@ # Written by Francois Fleuret -# torch.backends.cuda.matmul.allow_tf23 -# torch.autocast(torch.bfloat16) - -import math, sys, argparse, time, tqdm, itertools, os +import math, sys, argparse, time, tqdm, os, datetime, warnings import torch, torchvision from torch import nn from torch.nn import functional as F -import mygpt, tensorstack +import ffutils +import mygpt, tasks, problems ###################################################################### @@ -27,24 +25,36 @@ else: ###################################################################### parser = argparse.ArgumentParser( - description="An implementation of GPT with cache to solve a toy geometric reasoning task." + description="An implementation of GPT with cache.", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) -parser.add_argument("--task", type=str, default="picoclvr") +parser.add_argument( + "--task", + type=str, + default="twotargets", + help="file, byheart, learnop, guessop, mixing, memory, twotargets, addition, picoclvr, mnist, maze, snake, stack, expr, rpl, grid, qmlp, greed", +) -parser.add_argument("--log_filename", type=str, default="train.log") +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) -parser.add_argument("--nb_epochs", type=int, default=25) +parser.add_argument("--max_percents_of_test_in_train", type=int, default=1) + +######################################## + +parser.add_argument("--nb_epochs", type=int, default=50) + +parser.add_argument("--batch_size", type=int, default=None) -parser.add_argument("--batch_size", type=int, default=25) +parser.add_argument("--physical_batch_size", type=int, default=None) -parser.add_argument("--nb_train_samples", type=int, default=250000) +parser.add_argument("--nb_train_samples", type=int, default=None) -parser.add_argument("--nb_test_samples", type=int, default=10000) +parser.add_argument("--nb_test_samples", type=int, default=None) parser.add_argument("--optim", type=str, default="adam") @@ -52,732 +62,350 @@ parser.add_argument("--learning_rate", type=float, default=1e-4) parser.add_argument("--learning_rate_schedule", type=str, default="10: 2e-5,30: 4e-6") -parser.add_argument("--dim_model", type=int, default=512) +######################################## -parser.add_argument("--dim_keys", type=int, default=64) +parser.add_argument("--model", type=str, default=None) -parser.add_argument("--dim_hidden", type=int, default=2048) +parser.add_argument("--dim_model", type=int, default=None) -parser.add_argument("--nb_heads", type=int, default=8) +parser.add_argument("--dim_keys", type=int, default=None) -parser.add_argument("--nb_blocks", type=int, default=12) +parser.add_argument("--dim_hidden", type=int, default=None) + +parser.add_argument("--nb_heads", type=int, default=None) + +parser.add_argument("--nb_blocks", type=int, default=None) parser.add_argument("--dropout", type=float, default=0.1) +######################################## + parser.add_argument("--deterministic_synthesis", action="store_true", default=False) parser.add_argument("--no_checkpoint", action="store_true", default=False) -parser.add_argument("--overwrite_results", action="store_true", default=False) +parser.add_argument("--resume", action="store_true", default=False) parser.add_argument("--checkpoint_name", type=str, default="checkpoint.pth") ############################## -# picoclvr options - -parser.add_argument("--picoclvr_nb_colors", type=int, default=5) - -parser.add_argument("--picoclvr_height", type=int, default=12) - -parser.add_argument("--picoclvr_width", type=int, default=16) - -parser.add_argument("--picocvlr_prune_properties", type=str, default="none") - -############################## -# Maze options +# filetask -parser.add_argument("--maze_height", type=int, default=13) +parser.add_argument("--filetask_train_file", type=str, default=None) -parser.add_argument("--maze_width", type=int, default=21) - -parser.add_argument("--maze_nb_walls", type=int, default=15) +parser.add_argument("--filetask_test_file", type=str, default=None) ############################## -# Snake options - -parser.add_argument("--snake_height", type=int, default=6) - -parser.add_argument("--snake_width", type=int, default=8) - -parser.add_argument("--snake_nb_colors", type=int, default=3) - -parser.add_argument("--snake_length", type=int, default=400) - -###################################################################### - -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) +# rpl options -log_file = open(os.path.join(args.result_dir, args.log_filename), "a") +parser.add_argument("--rpl_nb_starting_values", type=int, default=3) -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) +parser.add_argument("--rpl_max_input", type=int, default=9) -###################################################################### +parser.add_argument("--rpl_prog_len", type=int, default=8) +parser.add_argument("--rpl_nb_runs", type=int, default=5) -def log_string(s): - t = time.strftime("%Y%m%d-%H:%M:%S ", time.localtime()) +parser.add_argument("--rpl_no_prog", action="store_true", default=False) - if log_file is not None: - log_file.write(t + s + "\n") - log_file.flush() +############################## +# grid options - print(t + s) - sys.stdout.flush() +parser.add_argument("--grid_size", type=int, default=6) +parser.add_argument("--grid_fraction_play", type=float, default=0) -for n in vars(args): - log_string(f"args.{n} {getattr(args, n)}") +############################## +# picoclvr options -###################################################################### +parser.add_argument("--picoclvr_nb_colors", type=int, default=5) +parser.add_argument("--picoclvr_height", type=int, default=12) -def masked_inplace_autoregression( - model, batch_size, input, ar_mask, forbidden_tokens=None, device=torch.device("cpu") -): - for input, ar_mask in zip(input.split(batch_size), ar_mask.split(batch_size)): - i = (ar_mask.sum(0) > 0).nonzero() - if i.min() > 0: - model( - mygpt.BracketedSequence(input, 0, i.min()) - ) # Needed to initialize the model's cache - for s in range(i.min(), i.max() + 1): - output = model(mygpt.BracketedSequence(input, s, 1)).x - logits = output[:, s] - if forbidden_tokens is not None: - logits = logits.masked_fill(forbidden_tokens, float("-inf")) - if args.deterministic_synthesis: - t_next = logits.argmax(1) - else: - dist = torch.distributions.categorical.Categorical(logits=logits) - t_next = dist.sample() - input[:, s] = ar_mask[:, s] * t_next + (1 - ar_mask[:, s]) * input[:, s] +parser.add_argument("--picoclvr_width", type=int, default=16) +parser.add_argument("--picocvlr_prune_properties", type=str, default="none") -###################################################################### +############################## +# Maze options +parser.add_argument("--maze_height", type=int, default=13) -class Task: - def batches(self, split="train"): - pass +parser.add_argument("--maze_width", type=int, default=21) - def vocabulary_size(self): - pass +parser.add_argument("--maze_nb_walls", type=int, default=15) - def produce_results(self, n_epoch, model): - pass +############################## +# Snake options +parser.add_argument("--snake_height", type=int, default=9) -###################################################################### +parser.add_argument("--snake_width", type=int, default=12) -import picoclvr - - -class TaskPicoCLVR(Task): - # Make a tensor from a list of strings - def tensorize(self, descr): - token_descr = [s.strip().split(" ") for s in descr] - l = max([len(s) for s in token_descr]) - token_descr = [s + [""] * (l - len(s)) for s in token_descr] - id_descr = [[self.token2id[u] for u in s] for s in token_descr] - return torch.tensor(id_descr, device=self.device) - - # Make a list of strings from a tensor - def detensorize(self, x): - return [" ".join([self.id2token[t.item()] for t in r]) for r in x] - - # trim all the tensors in the tuple z to remove as much token from - # left and right in the first tensor. If z is a tuple, all its - # elements are trimed according to the triming for the first - def trim(self, z, token=""): - n = self.token2id[token] - if type(z) == tuple: - x = z[0] - i = (1 - (F.pad(x, (1, 1), value=n) == n).min(0).values.long()).cumsum(0) - a, b = (i == 0).nonzero().max(), (i == i.max()).nonzero().min() - return tuple([t[:, a:b] for t in z]) - else: - i = (1 - (F.pad(z, (1, 1), value=n) == n).min(0).values.long()).cumsum(0) - a, b = (i == 0).nonzero().max(), (i == i.max()).nonzero().min() - return z[:, a:b] - - ###################### - # Not the cleanest part of the code - - # Extract the last image of each sequence, from the last - # included, and set to all the tokens from the beginning of - # that image to the end - def excise_last_image(self, input): - t_img, t_nul = self.token2id[""], self.token2id[""] - nb_img_tokens = self.height * self.width + 1 - - input = input.clone() - t = (input == t_img).long() - tail_masks = (t.cumsum(dim=1) == t.sum(dim=1, keepdim=True)).long() - i = (t * tail_masks).nonzero(as_tuple=True) - j = ( - i[0][:, None], - i[1][:, None] + torch.arange(nb_img_tokens, device=input.device)[None, :], - ) - images = self.trim(input[j]) - input[j] = t_nul - loss_masks = 1 - tail_masks - input, loss_masks = self.trim((input, loss_masks)) - return input, loss_masks, images - - def add_true_image(self, input, images, loss_masks): - t_nul = self.token2id[""] - nb_img_tokens = self.height * self.width + 1 - input = F.pad(input, (0, nb_img_tokens), value=t_nul) - loss_masks = F.pad(loss_masks, (0, nb_img_tokens), value=0) - t = (input == t_nul).long() - i = (t.cumsum(dim=1) == 1).nonzero(as_tuple=True) - j = ( - i[0][:, None], - i[1][:, None] + torch.arange(nb_img_tokens, device=input.device)[None, :], - ) - input[j] = images - loss_masks[j] = 1 - input, loss_masks = self.trim((input, loss_masks)) - return input, loss_masks - - def add_generated_image(self, input, loss_masks, model): - t_img, t_nul = self.token2id[""], self.token2id[""] - nb_img_tokens = self.height * self.width + 1 - - input = F.pad(input, (0, nb_img_tokens), value=t_nul) - loss_masks = F.pad(loss_masks, (0, nb_img_tokens), value=0) - t = (input == t_nul).long() - i = (t.cumsum(dim=1) == 1).nonzero(as_tuple=True) - input[i] = t_img - - j = ( - i[0][:, None], - i[1][:, None] - + 1 - + torch.arange(nb_img_tokens - 1, device=input.device)[None, :], - ) - ar_masks = input.new_zeros(input.size(), dtype=torch.int64) - ar_masks[j] = 1 - forbidden_tokens = ( - torch.arange(self.vocabulary_size(), device=input.device) == t_nul - ) - with torch.autograd.no_grad(): - t = model.training - model.eval() - masked_inplace_autoregression( - model, - self.batch_size, - input, - ar_masks, - forbidden_tokens, - device=self.device, - ) - model.train(t) +parser.add_argument("--snake_nb_colors", type=int, default=5) - input, loss_masks = self.trim((input, loss_masks)) +parser.add_argument("--snake_length", type=int, default=200) - return input, loss_masks +############################## +# ByHeart options - ###################### +parser.add_argument("--byheart_separation", type=int, default=1) - def __init__( - self, - nb_train_samples, - nb_test_samples, - batch_size, - height, - width, - nb_colors=5, - device=torch.device("cpu"), - pruner_train=None, - pruner_eval=None, - ): - def generate_descr(nb, cache_suffix, pruner): - return picoclvr.generate( - nb, - height=self.height, - width=self.width, - nb_colors=nb_colors, - pruner=pruner, - ) +############################## +# Stack options - self.height = height - self.width = width - self.batch_size = batch_size - self.device = device - self.pruner_train = pruner_train - self.pruner_eval = pruner_eval - - param = { - "nb_train_samples": nb_train_samples, - "nb_test_samples": nb_test_samples, - "height": height, - "width": width, - "nb_colors": nb_colors, - "batch_size": batch_size, - "rng_state": list(torch.get_rng_state()), - } +parser.add_argument("--stack_nb_steps", type=int, default=100) - log_string( - f"generating {nb_train_samples+nb_test_samples} samples (can take some time)" - ) - self.train_descr = generate_descr( - nb_train_samples, "train", pruner=self.pruner_train - ) - self.test_descr = generate_descr(nb_test_samples, "test", pruner=None) - - # Build the tokenizer - tokens = {"", ""} - for d in [self.train_descr, self.test_descr]: - for s in d: - for t in s.strip().split(" "): - tokens.add(t) - # make this set a sorted list to get the same tensors given - # the same descr - tokens = list(tokens) - tokens.sort() - self.token2id = dict([(t, n) for n, t in enumerate(tokens)]) - self.id2token = dict([(n, t) for n, t in enumerate(tokens)]) - - # Tokenize the train and test sets - self.train_input = self.tensorize(self.train_descr) - self.test_input = self.tensorize(self.test_descr) - - def batches(self, split="train"): - assert split in {"train", "test"} - input = self.train_input if split == "train" else self.test_input - for batch in tqdm.tqdm( - input.split(self.batch_size), dynamic_ncols=True, desc=f"epoch-{split}" - ): - yield self.trim(batch) +parser.add_argument("--stack_nb_stacks", type=int, default=3) - def vocabulary_size(self): - return len(self.token2id) +parser.add_argument("--stack_nb_digits", type=int, default=3) - def compute_missing_properties(self, n_epoch, model, pruner=None): - acc_nb_requested_properties = [] - acc_nb_missing_properties = [] - acc_nb_results = 0 +parser.add_argument("--stack_fraction_values_for_train", type=float, default=None) - for input in tqdm.tqdm( - self.test_input.split(self.batch_size), - dynamic_ncols=True, - desc=f"test-properties", - ): - tape, loss_masks, _ = self.excise_last_image(input) - tape, loss_masks = self.add_generated_image(tape, loss_masks, model) - result_descr = self.detensorize(tape) - np = picoclvr.nb_properties( - result_descr, - height=self.height, - width=self.width, - pruner=pruner, - ) - nb_requested_properties, _, nb_missing_properties = zip(*np) - acc_nb_requested_properties += nb_requested_properties - acc_nb_missing_properties += nb_missing_properties - acc_nb_results += len(result_descr) +############################## +# Expr options - nb_requested_properties = sum(acc_nb_requested_properties) - nb_missing_properties = sum(acc_nb_missing_properties) +parser.add_argument("--expr_nb_variables", type=int, default=5) - prefix = "" if pruner is None else "pruned_" - log_string(f"nb_{prefix}samples {n_epoch} {acc_nb_results}") - log_string( - f"property_{prefix}nb {n_epoch} requested {sum(acc_nb_requested_properties)} missing {sum(acc_nb_missing_properties)}" - ) - log_string( - f"property_{prefix}miss {n_epoch} {100*nb_missing_properties/nb_requested_properties:.02f}%" - ) +parser.add_argument("--expr_sequence_length", type=int, default=40) - ###################################################################### +parser.add_argument("--expr_operand_max", type=int, default=9) - def produce_results(self, n_epoch, model): - self.compute_missing_properties(n_epoch, model) +parser.add_argument("--expr_result_max", type=int, default=99) - if self.pruner_eval is not None: - self.compute_missing_properties(n_epoch, model, self.pruner_eval) +parser.add_argument("--expr_input_file", type=str, default=None) - nb_tokens_to_generate = self.height * self.width + 3 - result_descr = [] - nb_per_primer = 8 - primer = [] +############################## +# Mixing - for primer_descr in [ - "red above green green top blue right of red", - "there is red there is yellow there is blue", - "red below yellow yellow below green green below blue red right yellow left green right blue left", - "green bottom yellow bottom green left of blue yellow right of blue blue top", - ]: - primer += [primer_descr] * nb_per_primer +parser.add_argument("--mixing_hard", action="store_true", default=False) - tape = self.tensorize(primer) - loss_masks = 1 - (tape == self.token2id[""]).long() - tape, loss_masks = self.add_generated_image(tape, loss_masks, model) - result_descr = self.detensorize(tape) +parser.add_argument("--mixing_deterministic_start", action="store_true", default=False) - np = picoclvr.nb_properties(result_descr, height=self.height, width=self.width) +############################## +# greed options - acc_nb_requested_properties, _, acc_nb_missing_properties = zip(*np) - acc_nb_results = len(result_descr) +parser.add_argument("--greed_height", type=int, default=5) - nb_requested_properties = sum(acc_nb_requested_properties) - nb_missing_properties = sum(acc_nb_missing_properties) +parser.add_argument("--greed_width", type=int, default=7) - prefix = "demo_" - log_string(f"nb_{prefix}samples {n_epoch} {acc_nb_results}") - log_string( - f"property_{prefix}nb {n_epoch} requested {sum(acc_nb_requested_properties)} missing {sum(acc_nb_missing_properties)}" - ) - log_string( - f"property_{prefix}miss {n_epoch} {100*nb_missing_properties/nb_requested_properties:.02f}%" - ) +parser.add_argument("--greed_T", type=int, default=25) - img = picoclvr.descr2img(result_descr, height=self.height, width=self.width) - - if img.dim() == 5: - if img.size(1) == 1: - img = F.pad(img.squeeze(1), pad=(1, 1, 1, 1), value=64) - else: - img = torch.cat( - [ - torchvision.utils.make_grid(x, padding=1, pad_value=64)[None] - for x in img - ], - 0, - ) - - image_name = os.path.join(args.result_dir, f"picoclvr_result_{n_epoch:04d}.png") - torchvision.utils.save_image( - img / 255.0, image_name, nrow=nb_per_primer, padding=1, pad_value=1.0 - ) - log_string(f"wrote {image_name}") +parser.add_argument("--greed_nb_walls", type=int, default=5) +parser.add_argument("--greed_nb_coins", type=int, default=2) ###################################################################### +args = parser.parse_args() -class TaskMNIST(Task): - def __init__(self, batch_size, device=torch.device("cpu")): - self.device = device - self.batch_size = batch_size - - def batches(self, split="train"): - assert split in {"train", "test"} - data_set = torchvision.datasets.MNIST( - root="./data", train=(split == "train"), download=True - ) - data_input = data_set.data.view(-1, 28 * 28).long() - if args.nb_train_samples is not None: - data_input = data_input[: args.nb_train_samples] - for batch in tqdm.tqdm( - data_input.split(self.batch_size), desc=f"epoch-{split}" - ): - yield batch - - def vocabulary_size(self): - return 256 - - def produce_results(self, n_epoch, model): - results = torch.empty(64, 28 * 28, device=self.device, dtype=torch.int64) - ar_mask = torch.full_like(results, 1) - masked_inplace_autoregression( - model, self.batch_size, results, ar_mask, device=self.device - ) - image_name = os.path.join(args.result_dir, f"mnist_result_{n_epoch:04d}.png") - torchvision.utils.save_image( - 1 - results.reshape(-1, 1, 28, 28) / 255.0, - image_name, - nrow=16, - pad_value=0.8, - ) - log_string(f"wrote {image_name}") +assert args.picocvlr_prune_properties in {"none", "train+eval", "eval"} +if args.result_dir is None: + args.result_dir = f"results_{args.task}" ###################################################################### -import maze - - -class TaskMaze(Task): - def map2seq(self, *m): - return torch.cat([x.flatten(1) for x in m], 1) - - def seq2map(self, s): - s = s.reshape(s.size(0), -1, self.height, self.width) - return (s[:, k] for k in range(s.size(1))) - - def __init__( - self, - nb_train_samples, - nb_test_samples, - batch_size, - height, - width, - nb_walls, - device=torch.device("cpu"), - ): - self.batch_size = batch_size - self.height = height - self.width = width - self.device = device - - train_mazes, train_paths, _ = maze.create_maze_data( - nb_train_samples, - height=height, - width=width, - nb_walls=nb_walls, - progress_bar=lambda x: tqdm.tqdm(x, dynamic_ncols=True, desc=f"data-train"), - ) - self.train_input = self.map2seq(train_mazes.to(device), train_paths.to(device)) - - test_mazes, test_paths, _ = maze.create_maze_data( - nb_test_samples, - height=height, - width=width, - nb_walls=nb_walls, - progress_bar=lambda x: tqdm.tqdm(x, dynamic_ncols=True, desc=f"data-test"), - ) - self.test_input = self.map2seq(test_mazes.to(device), test_paths.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 compute_error(self, model, split="train", nb_to_use=-1): - nb_total, nb_correct = 0, 0 - for input in task.batches(split, nb_to_use): - result = input.clone() - ar_mask = result.new_zeros(result.size()) - ar_mask[:, self.height * self.width :] = 1 - result *= 1 - ar_mask - masked_inplace_autoregression( - model, self.batch_size, result, ar_mask, device=self.device - ) - mazes, paths = self.seq2map(result) - nb_correct += maze.path_correctness(mazes, paths).long().sum() - nb_total += mazes.size(0) - - return nb_total, nb_correct - - def produce_results(self, n_epoch, model): - with torch.autograd.no_grad(): - t = model.training - model.eval() - - train_nb_total, train_nb_correct = self.compute_error( - 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}%" - ) - - test_nb_total, test_nb_correct = 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}%" - ) - - input = self.test_input[:48] - result = input.clone() - ar_mask = result.new_zeros(result.size()) - ar_mask[:, self.height * self.width :] = 1 - result *= 1 - ar_mask - masked_inplace_autoregression( - model, self.batch_size, result, ar_mask, device=self.device - ) - - mazes, paths = self.seq2map(input) - _, predicted_paths = self.seq2map(result) - - filename = os.path.join(args.result_dir, f"maze_result_{n_epoch:04d}.png") - maze.save_image( - filename, - mazes=mazes, - target_paths=paths, - predicted_paths=predicted_paths, - path_correct=maze.path_correctness(mazes, predicted_paths), - ) - log_string(f"wrote {filename}") - - model.train(t) - +default_task_args = { + "file": { + "model": "37M", + "batch_size": 25, + "nb_train_samples": 250000, + "nb_test_samples": 10000, + }, + "addition": { + "model": "352M", + "batch_size": 25, + "nb_train_samples": 250000, + "nb_test_samples": 10000, + }, + "byheart": { + "model": "37M", + "batch_size": 25, + "nb_train_samples": 50000, + "nb_test_samples": 10000, + }, + "expr": { + "model": "352M", + "batch_size": 25, + "nb_train_samples": 2500000, + "nb_test_samples": 10000, + }, + "grid": { + "model": "37M", + "batch_size": 25, + "nb_train_samples": 250000, + "nb_test_samples": 10000, + }, + "qmlp": { + "model": "37M", + "batch_size": 10, + "nb_train_samples": 100000, + "nb_test_samples": 1000, + }, + "guessop": { + "model": "352M", + "batch_size": 25, + "nb_train_samples": 1000000, + "nb_test_samples": 10000, + }, + "learnop": { + "model": "37M", + "batch_size": 25, + "nb_train_samples": 50000, + "nb_test_samples": 10000, + }, + "maze": { + "model": "37M", + "batch_size": 5, + "nb_train_samples": 100000, + "nb_test_samples": 10000, + }, + "picoclvr": { + "model": "37M", + "batch_size": 25, + "nb_train_samples": 250000, + "nb_test_samples": 10000, + }, + "rpl": { + "model": "352M", + "batch_size": 5, + "nb_train_samples": 2500000, + "nb_test_samples": 10000, + }, + "snake": { + "model": "37M", + "batch_size": 25, + "nb_train_samples": 250000, + "nb_test_samples": 10000, + }, + "stack": { + "model": "37M", + "batch_size": 25, + "nb_train_samples": 100000, + "nb_test_samples": 1000, + }, + "twotargets": { + "model": "37M", + "batch_size": 25, + "nb_train_samples": 50000, + "nb_test_samples": 10000, + }, + "memory": { + "model": "37M", + "batch_size": 100, + "nb_train_samples": 25000, + "nb_test_samples": 1000, + }, + "mixing": { + "model": "37M", + "batch_size": 25, + "nb_train_samples": 250000, + "nb_test_samples": 10000, + }, + "mnist": { + "model": "37M", + "batch_size": 10, + "nb_train_samples": 60000, + "nb_test_samples": 10000, + }, + "greed": { + "model": "37M", + "batch_size": 25, + "nb_train_samples": 25000, + "nb_test_samples": 10000, + }, +} + +if args.task in default_task_args: + for k, v in default_task_args[args.task].items(): + if getattr(args, k) is None: + setattr(args, k, v) ###################################################################### +default_model_args = { + "17K": { + "dim_model": 32, + "dim_keys": 32, + "dim_hidden": 32, + "nb_heads": 2, + "nb_blocks": 2, + }, + "4M": { + "dim_model": 256, + "dim_keys": 32, + "dim_hidden": 1024, + "nb_heads": 4, + "nb_blocks": 6, + }, + "37M": { + "dim_model": 512, + "dim_keys": 64, + "dim_hidden": 2048, + "nb_heads": 8, + "nb_blocks": 12, + }, + "122M": { + "dim_model": 768, + "dim_keys": 64, + "dim_hidden": 2048, + "nb_heads": 8, + "nb_blocks": 24, + }, + "352M": { + "dim_model": 1024, + "dim_keys": 64, + "dim_hidden": 2048, + "nb_heads": 8, + "nb_blocks": 48, + }, +} + +if args.model in default_model_args: + for k, v in default_model_args[args.model].items(): + if getattr(args, k) is None: + setattr(args, k, v) +else: + raise ValueError(f"Unknown model {args.model}") -def generate_snake_sequences( - nb, height, width, nb_colors, length, device=torch.device("cpu") -): - worlds = torch.randint(nb_colors, (nb, height, width), device=device) - # nb x 2 - snake_position = torch.cat( - ( - torch.randint(height, (nb, 1), device=device), - torch.randint(width, (nb, 1), device=device), - ), - 1, - ) - snake_direction = torch.randint(4, (nb,), device=device) - sequences = torch.empty(nb, 2 * length, device=device, dtype=torch.int64) - i = torch.arange(nb, device=device) # [:,None] - - for l in range(length): - # nb x 3 - snake_next_direction = torch.cat( - ( - (snake_direction[:, None] - 1) % 4, - snake_direction[:, None], - (snake_direction[:, None] + 1) % 4, - ), - 1, - ) - - # nb x 3 - vh = (snake_next_direction + 1) % 2 * (snake_next_direction - 1) - vw = snake_next_direction % 2 * (snake_next_direction - 2) - - # nb x 3 x 2 - snake_next_speed = torch.cat((vh[:, :, None], vw[:, :, None]), 2) - snake_next_position = snake_position[:, None, :] + snake_next_speed - - # nb x 3 - val = torch.logical_and( - torch.logical_and( - snake_next_position[:, :, 0] >= 0, snake_next_position[:, :, 0] < height - ), - torch.logical_and( - snake_next_position[:, :, 1] >= 0, snake_next_position[:, :, 1] < width - ), - ).float() - val = ( - torch.rand_like(val) * val * torch.tensor([[1.0, 4.0, 1.0]], device=device) - ) - - # nb - j = val.argmax(1) - snake_direction = snake_next_direction[i, j] - - sequences[:, 2 * l] = worlds[i, snake_position[:, 0], snake_position[:, 1]] + 4 - sequences[:, 2 * l + 1] = snake_direction - - # nb x 2 - snake_position = snake_next_position[i, j] - - return sequences, worlds - - -# generate_snake_sequences(nb=1, height=4, width=6, nb_colors=3, length=20) -# exit(0) - - -class TaskSnake(Task): - def __init__( - self, - nb_train_samples, - nb_test_samples, - batch_size, - height, - width, - nb_colors, - length, - device=torch.device("cpu"), - ): - self.batch_size = batch_size - self.height = height - self.width = width - self.device = device - - self.train_input, self.train_worlds = generate_snake_sequences( - nb_train_samples, height, width, nb_colors, length, self.device - ) - self.test_input, self.test_worlds = generate_snake_sequences( - nb_test_samples, height, width, nb_colors, length, self.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 +try: + os.mkdir(args.result_dir) +except FileExistsError: + if not args.resume: + print(f"result directory {args.result_dir} already exists") + exit(1) - def produce_results(self, n_epoch, model): - with torch.autograd.no_grad(): - t = model.training - model.eval() +log_file = open(os.path.join(args.result_dir, args.log_filename), "a") - def compute_nb_correct(input): - result = input.clone() - i = torch.arange(result.size(1), device=result.device) - ar_mask = torch.logical_and(i >= i.size(0) // 2, i % 2 == 0)[ - None, : - ].long() - result *= 1 - ar_mask - masked_inplace_autoregression( - model, self.batch_size, result, ar_mask, device=self.device - ) +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) - nb_total = ar_mask.sum() * input.size(0) - nb_correct = ((result == input).long() * ar_mask).sum() +###################################################################### - # nb_total = result.size(0) - # nb_correct = ((result - input).abs().sum(1) == 0).sum() - return nb_total, nb_correct +def log_string(s): + t = time.strftime("%Y%m%d-%H:%M:%S ", time.localtime()) - train_nb_total, train_nb_correct = compute_nb_correct(self.train_input) + if log_file is not None: + log_file.write(t + s + "\n") + log_file.flush() - 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}%" - ) + print(t + s) + sys.stdout.flush() - test_nb_total, test_nb_correct = compute_nb_correct(self.test_input) - 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}%" - ) +log_string(f"argv {' '.join(sys.argv)}") - model.train(t) +for n in vars(args): + log_string(f"args.{n} {getattr(args, n)}") ###################################################################### @@ -801,45 +429,221 @@ picoclvr_pruner_eval = ( ###################################################################### -if args.task == "picoclvr": - task = TaskPicoCLVR( +if args.physical_batch_size is None: + args.physical_batch_size = args.batch_size +else: + assert args.batch_size % args.physical_batch_size == 0 + +assert args.nb_train_samples % args.batch_size == 0 +assert args.nb_test_samples % args.batch_size == 0 + +if args.task == "file": + assert ( + args.filetask_train_file is not None and args.filetask_test_file is not None + ), "You have to specify the task train and test files" + task = tasks.TaskFromFile( + args.filetask_train_file, + args.filetask_test_file, + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + shuffle=True, + device=device, + ) + args.max_percents_of_test_in_train = 0 + +elif args.task == "byheart": + task = tasks.SandBox( + problem=problems.ProblemByHeart(separation=args.byheart_separation), + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + logger=log_string, + device=device, + ) + args.max_percents_of_test_in_train = -1 + +elif args.task == "learnop": + task = tasks.SandBox( + problem=problems.ProblemLearnOperator(), nb_train_samples=args.nb_train_samples, nb_test_samples=args.nb_test_samples, - batch_size=args.batch_size, + batch_size=args.physical_batch_size, + logger=log_string, + device=device, + ) + + +elif args.task == "guessop": + task = tasks.SandBox( + problem=problems.ProblemGuessOperator(), + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + logger=log_string, + device=device, + ) + + +elif args.task == "twotargets": + task = tasks.SandBox( + problem=problems.ProblemTwoTargets(), + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + logger=log_string, + device=device, + ) + +elif args.task == "memory": + task = tasks.SandBox( + problem=problems.ProblemMemory(), + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + logger=log_string, + device=device, + ) + +elif args.task == "mixing": + task = tasks.SandBox( + problem=problems.ProblemMixing( + hard=args.mixing_hard, random_start=not args.mixing_deterministic_start + ), + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + logger=log_string, + device=device, + ) + +elif args.task == "addition": + task = tasks.SandBox( + problem=problems.ProblemAddition(), + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + logger=log_string, + device=device, + ) + +elif args.task == "picoclvr": + task = tasks.PicoCLVR( + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, height=args.picoclvr_height, width=args.picoclvr_width, nb_colors=args.picoclvr_nb_colors, + logger=log_string, device=device, pruner_train=picoclvr_pruner_train, pruner_eval=picoclvr_pruner_eval, ) elif args.task == "mnist": - task = TaskMNIST( - batch_size=args.batch_size, + task = tasks.MNIST( + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, device=device, ) elif args.task == "maze": - task = TaskMaze( + task = tasks.Maze( nb_train_samples=args.nb_train_samples, nb_test_samples=args.nb_test_samples, - batch_size=args.batch_size, + batch_size=args.physical_batch_size, height=args.maze_height, width=args.maze_width, nb_walls=args.maze_nb_walls, - device=device, + device="cpu", ) elif args.task == "snake": - task = TaskSnake( + task = tasks.Snake( nb_train_samples=args.nb_train_samples, nb_test_samples=args.nb_test_samples, - batch_size=args.batch_size, + batch_size=args.physical_batch_size, height=args.snake_height, width=args.snake_width, nb_colors=args.snake_nb_colors, length=args.snake_length, + prompt_length=args.snake_length // 2, + device=device, + ) + +elif args.task == "stack": + task = tasks.Stack( + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + logger=log_string, + nb_steps=args.stack_nb_steps, + nb_stacks=args.stack_nb_stacks, + nb_digits=args.stack_nb_digits, + fraction_values_for_train=args.stack_fraction_values_for_train, + device=device, + ) + +elif args.task == "expr": + task = tasks.Expr( + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + nb_variables=args.expr_nb_variables, + sequence_length=args.expr_sequence_length, + operand_max=args.expr_operand_max, + result_max=args.expr_result_max, + batch_size=args.physical_batch_size, + device=device, + ) + +elif args.task == "rpl": + task = tasks.RPL( + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + nb_starting_values=args.rpl_nb_starting_values, + max_input=args.rpl_max_input, + prog_len=args.rpl_prog_len, + nb_runs=args.rpl_nb_runs, + no_prog=args.rpl_no_prog, + logger=log_string, + device=device, + ) + +elif args.task == "grid": + task = tasks.Grid( + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + size=args.grid_size, + fraction_play=args.grid_fraction_play, + logger=log_string, + device=device, + ) + +elif args.task == "qmlp": + task = tasks.QMLP( + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + result_dir=args.result_dir, + logger=log_string, + device=device, + ) + +elif args.task == "greed": + task = tasks.Greed( + nb_train_samples=args.nb_train_samples, + nb_test_samples=args.nb_test_samples, + batch_size=args.physical_batch_size, + height=args.greed_height, + width=args.greed_width, + T=args.greed_T, + nb_walls=args.greed_nb_walls, + nb_coins=args.greed_nb_coins, + logger=log_string, device=device, ) @@ -900,15 +704,64 @@ else: ###################################################################### -nb_epochs = args.nb_epochs if args.nb_epochs > 0 else nb_epochs_default +if args.task == "expr" and args.expr_input_file is not None: + task.produce_results( + n_epoch=nb_epochs_finished, + model=model, + result_dir=args.result_dir, + logger=log_string, + deterministic_synthesis=args.deterministic_synthesis, + input_file=args.expr_input_file, + ) + + exit(0) + +###################################################################### + +# Compute the entropy of the training tokens token_count = 0 -for input in task.batches(split="train"): +for input in task.batches(split="train", desc="train-entropy"): token_count += F.one_hot(input, num_classes=task.vocabulary_size()).sum((0, 1)) token_probas = token_count / token_count.sum() entropy = -torch.xlogy(token_probas, token_probas).sum() train_set_perplexity = math.exp(entropy) +###################################################################### +# A bit of paranoia never hurts + +if args.max_percents_of_test_in_train >= 0: + + def subsets_as_tuples(batches, cs): + s = set() + for batch in batches: + for x in batch: + s.add(tuple([v.item() for v in x])) + if len(s) == cs: + yield s + s = set() + yield s + + nb_test, nb_in_train = 0, 0 + for test_subset in subsets_as_tuples( + task.batches(split="test", desc="test-check"), 25000 + ): + in_train = set() + for train_subset in subsets_as_tuples( + task.batches(split="train", desc="train-check"), 25000 + ): + in_train.update(test_subset.intersection(train_subset)) + nb_in_train += len(in_train) + nb_test += len(test_subset) + + log_string( + f"data_check {nb_in_train*100/nb_test:.02f}% ({nb_in_train}/{nb_test}) of test samples are in the train set" + ) + + assert ( + nb_in_train <= args.max_percents_of_test_in_train * nb_test / 100 + ), f"More than {args.max_percents_of_test_in_train}% of test samples are in the train set" + ############################## if args.learning_rate_schedule == "cos": @@ -935,12 +788,18 @@ log_string(f"learning_rate_schedule {learning_rate_schedule}") ############################## -nb_samples_seen = 0 +if nb_epochs_finished >= args.nb_epochs: + task.produce_results( + n_epoch=nb_epochs_finished, + model=model, + result_dir=args.result_dir, + logger=log_string, + deterministic_synthesis=args.deterministic_synthesis, + ) -if nb_epochs_finished >= nb_epochs: - task.produce_results(nb_epochs_finished, model) +time_pred_result = None -for n_epoch in range(nb_epochs_finished, nb_epochs): +for n_epoch in range(nb_epochs_finished, args.nb_epochs): learning_rate = learning_rate_schedule[n_epoch] log_string(f"learning_rate {learning_rate}") @@ -960,30 +819,37 @@ for n_epoch in range(nb_epochs_finished, nb_epochs): for input in task.batches(split="train"): input = input.to(device) + + if nb_train_samples % args.batch_size == 0: + optimizer.zero_grad() + output = model(mygpt.BracketedSequence(input)).x loss = F.cross_entropy(output.transpose(1, 2), input) acc_train_loss += loss.item() * input.size(0) + nb_train_samples += input.size(0) - nb_samples_seen += input.size(0) - optimizer.zero_grad() loss.backward() - optimizer.step() + + if nb_train_samples % args.batch_size == 0: + optimizer.step() with torch.autograd.no_grad(): model.eval() nb_test_samples, acc_test_loss = 0, 0.0 + nb_samples_accumulated = 0 for input in task.batches(split="test"): input = input.to(device) - # input, loss_masks, true_images = task.excise_last_image(input) - # input, loss_masks = task.add_true_image(input, true_images, loss_masks) + bs = model(mygpt.BracketedSequence(input)) + output = bs.x - output = model(mygpt.BracketedSequence(input)).x loss = F.cross_entropy(output.transpose(1, 2), input) + acc_test_loss += loss.item() * input.size(0) + nb_test_samples += input.size(0) train_perplexity = math.exp(min(100, acc_train_loss / nb_train_samples)) @@ -993,7 +859,20 @@ for n_epoch in range(nb_epochs_finished, nb_epochs): f"perplexity {n_epoch} train_set {train_set_perplexity} train_prediction {train_perplexity} test_prediction {test_perplexity}" ) - task.produce_results(n_epoch, model) + task.produce_results( + n_epoch=n_epoch, + model=model, + result_dir=args.result_dir, + logger=log_string, + deterministic_synthesis=args.deterministic_synthesis, + ) + + time_current_result = datetime.datetime.now() + if time_pred_result is not None: + log_string( + f"next_result {time_current_result + (time_current_result - time_pred_result)}" + ) + time_pred_result = time_current_result checkpoint = { "nb_epochs_finished": n_epoch + 1,