X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=tasks.py;h=066f1bbec05fcc0d65365823ea60931010e118cb;hb=26ef53ee3769c3b6b92b85d15b5a43cbd18ede07;hp=c7348d50653cbb58ace6e040bf861b7028513e9e;hpb=6f61f9438799d65c980726e28546f8775bf83a60;p=picoclvr.git diff --git a/tasks.py b/tasks.py index c7348d5..066f1bb 100755 --- a/tasks.py +++ b/tasks.py @@ -1426,21 +1426,21 @@ import grid class Grid(Task): # Make a tensor from a list of strings - def tensorize(self, descr): + def str2tensor(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] + 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): + def tensor2str(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=""): + def trim(self, z, token="#"): n = self.token2id[token] if type(z) == tuple: x = z[0] @@ -1459,8 +1459,7 @@ class Grid(Task): nb_train_samples, nb_test_samples, batch_size, - height, - width, + size, logger=None, device=torch.device("cpu"), ): @@ -1468,7 +1467,7 @@ class Grid(Task): self.device = device self.batch_size = batch_size - self.grid_factory = grid.GridFactory(height=height, width=width) + self.grid_factory = grid.GridFactory(size=size) if logger is not None: logger( @@ -1483,7 +1482,7 @@ class Grid(Task): ) # Build the tokenizer - tokens = {} + tokens = set() for d in [self.train_descr, self.test_descr]: for s in d: for t in s.strip().split(" "): @@ -1492,16 +1491,16 @@ class Grid(Task): # the same descr tokens = list(tokens) tokens.sort() - tokens = [""] + tokens + tokens = ["#"] + tokens self.token2id = dict([(t, n) for n, t in enumerate(tokens)]) self.id2token = dict([(n, t) for n, t in enumerate(tokens)]) - self.t_nul = self.token2id[""] - self.t_true = self.token2id[""] - self.t_false = self.token2id[""] + self.t_nul = self.token2id["#"] + self.t_true = self.token2id["true"] + self.t_false = self.token2id["false"] # Tokenize the train and test sets - self.train_input = self.tensorize(self.train_descr) - self.test_input = self.tensorize(self.test_descr) + self.train_input = self.str2tensor(self.train_descr) + self.test_input = self.str2tensor(self.test_descr) def batches(self, split="train"): assert split in {"train", "test"} @@ -1520,9 +1519,11 @@ class Grid(Task): correct = self.test_input[:1000] result = correct.clone() ar_mask = torch.logical_or(result == self.t_true, result == self.t_false).long() - result *= 1 - ar_mask + result *= 1 - ar_mask # paraaaaanoiaaaaaaa + + logger(f"----------------------------------------------------------") - for e in self.detensorize(result[:10]): + for e in self.tensor2str(result[:10]): logger(f"test_before {e}") masked_inplace_autoregression( @@ -1534,89 +1535,71 @@ class Grid(Task): device=self.device, ) - for e in self.detensorize(result[:10]): - logger(f"test_after {e}") + logger(f"----------------------------------------------------------") + + for e in self.tensor2str(result[:10]): + logger(f"test_after {e}") + + logger(f"----------------------------------------------------------") nb_total = ar_mask.sum().item() nb_correct = ((correct == result).long() * ar_mask).sum().item() - logger(f"test_performance {nb_total=} {nb_correct=}") - logger(f"main_test_accuracy {nb_correct / nb_total}") + logger(f"test_performance {n_epoch} {nb_total=} {nb_correct=}") + logger(f"main_test_accuracy {n_epoch} {nb_correct / nb_total}") ###################################################################### -import world +import qmlp + +class QMLP(Task): + + ###################### -class World(Task): def __init__( self, nb_train_samples, nb_test_samples, batch_size, - vqae_nb_epochs, logger=None, device=torch.device("cpu"), - device_storage=torch.device("cpu"), ): super().__init__() - self.batch_size = batch_size self.device = device + self.batch_size = batch_size + self.nb_samples_per_mlp = 256 - ( - train_frames, - train_action_seq, - test_frames, - test_action_seq, - self.frame2seq, - self.seq2frame, - ) = world.create_data_and_processors( - nb_train_samples, - nb_test_samples, - mode="first_last", - nb_steps=30, - nb_epochs=vqae_nb_epochs, - logger=logger, - device=device, - device_storage=device_storage, - ) - - train_frame_seq = self.frame2seq(train_frames).to(device_storage) - test_frame_seq = self.frame2seq(test_frames).to(device_storage) - - nb_frame_codes = max(train_frame_seq.max(), test_frame_seq.max()) + 1 - nb_action_codes = max(train_action_seq.max(), test_action_seq.max()) + 1 - - self.len_frame_seq = train_frame_seq.size(1) - self.len_action_seq = train_action_seq.size(1) - self.nb_codes = nb_frame_codes + nb_action_codes - - train_frame_seq = train_frame_seq.reshape(train_frame_seq.size(0) // 2, 2, -1) + if logger is not None: + logger( + f"generating {nb_train_samples+nb_test_samples} samples (can take some time)" + ) - train_action_seq += nb_frame_codes - self.train_input = torch.cat( - (train_frame_seq[:, 0, :], train_action_seq, train_frame_seq[:, 1, :]), 1 + seq, q_test_set = generate_sequence_and_test_set( + nb_mlps=nb_train_samples+nb_test_samples, + nb_samples=self.nb_samples_per_mlp, + device=self.device, + batch_size=64, + nb_epochs=250, + nb_mlps_per_batch=1024 ) - test_frame_seq = test_frame_seq.reshape(test_frame_seq.size(0) // 2, 2, -1) - test_action_seq += nb_frame_codes - self.test_input = torch.cat( - (test_frame_seq[:, 0, :], test_action_seq, test_frame_seq[:, 1, :]), 1 - ) + self.train_input = seq[:nb_train_samples] + self.train_q_test_set = q_test_set[:nb_train_samples] + self.test_input = seq[nb_train_samples:] + self.test_q_test_set = q_test_set[nb_train_samples:] - def batches(self, split="train", nb_to_use=-1, desc=None): + self.nb_codes = max(self.train_input.max(), self.test_input.max()) + 1 + + def batches(self, split="train"): 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 + input.split(self.batch_size), dynamic_ncols=True, desc=f"epoch-{split}" ): - yield batch.to(self.device) + yield self.trim(batch) def vocabulary_size(self): return self.nb_codes @@ -1624,17 +1607,15 @@ class World(Task): def produce_results( self, n_epoch, model, result_dir, logger, deterministic_synthesis ): - k = torch.arange( - 2 * self.len_frame_seq + self.len_action_seq, device=self.device - )[None, :] + correct = self.test_input[:1000] + result = correct.clone() + ar_mask = torch.arange(result.size(1)) > self.nb_samples_per_mlp * 3 + 1 + result *= 1 - ar_mask # paraaaaanoiaaaaaaa - input = self.test_input[:64].to(self.device) - result = input.clone() + logger(f"----------------------------------------------------------") - ar_mask = ( - (k >= self.len_frame_seq + self.len_action_seq).long().expand_as(result) - ) - result *= 1 - ar_mask + for e in self.tensor2str(result[:10]): + logger(f"test_before {e}") masked_inplace_autoregression( model, @@ -1645,25 +1626,18 @@ class World(Task): device=self.device, ) - seq_start = input[:, : self.len_frame_seq] - seq_end = input[:, self.len_frame_seq + self.len_action_seq :] - seq_predicted = result[:, self.len_frame_seq + self.len_action_seq :] + logger(f"----------------------------------------------------------") - result = torch.cat( - (seq_start[:, None, :], seq_end[:, None, :], seq_predicted[:, None, :]), 1 - ) - result = result.reshape(-1, result.size(-1)) + for e in self.tensor2str(result[:10]): + logger(f"test_after {e}") - frames = self.seq2frame(result) - image_name = os.path.join(result_dir, f"world_result_{n_epoch:04d}.png") - torchvision.utils.save_image( - frames.float() / (world.Box.nb_rgb_levels - 1), - image_name, - nrow=12, - padding=1, - pad_value=0.0, - ) - logger(f"wrote {image_name}") + logger(f"----------------------------------------------------------") + + q_train_set = result[:, : nb_samples * 3] + q_params = result[:, nb_samples * 3 + 1 :] + error_test = evaluate_q_params(q_params, q_test_set, nb_mlps_per_batch=17) + + logger(f"{error_test=}") ######################################################################