+ # Build the tokenizer
+ tokens = set()
+ for d in [self.train_descr, self.test_descr, self.play_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()
+ 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["true"]
+ self.t_false = self.token2id["false"]
+ # self.t_pipe = self.token2id["|"]
+
+ # Tokenize the train and test sets
+ self.train_input = self.str2tensor(self.train_descr)
+ self.test_input = self.str2tensor(self.test_descr)
+ self.play_input = (
+ None if len(self.play_descr) == 0 else self.str2tensor(self.play_descr)
+ )
+
+ 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
+ for batch in tqdm.tqdm(
+ input.split(self.batch_size), dynamic_ncols=True, desc=f"epoch-{split}"
+ ):
+ yield self.trim(batch)
+
+ def vocabulary_size(self):
+ return len(self.token2id)
+
+ def produce_results(
+ self, n_epoch, model, result_dir, logger, deterministic_synthesis
+ ):
+ 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 # paraaaaanoiaaaaaaa
+
+ logger(f"----------------------------------------------------------")
+
+ for e in self.tensor2str(result[:10]):
+ logger(f"test_before {e}")
+
+ masked_inplace_autoregression(
+ model,
+ self.batch_size,
+ result,
+ ar_mask,
+ deterministic_synthesis,
+ device=self.device,
+ )
+
+ 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 {n_epoch} {nb_total=} {nb_correct=}")
+ logger(f"main_test_accuracy {n_epoch} {nb_correct / nb_total}")
+
+ if self.play_input is not None:
+ result = self.play_input.clone()
+ ar_mask = (result == self.t_pipe).long().cumsum(dim=1).clamp(max=1)
+ result *= 1 - ar_mask # paraaaaanoiaaaaaaa
+
+ logger(f"----------------------------------------------------------")
+
+ for e in self.tensor2str(result[:10]):
+ logger(f"play_before {e}")
+
+ masked_inplace_autoregression(
+ model,
+ self.batch_size,
+ result,
+ ar_mask,
+ deterministic_synthesis,
+ device=self.device,
+ )
+
+ logger(f"----------------------------------------------------------")
+
+ for e in self.tensor2str(result[:10]):
+ logger(f"play_after {e}")
+
+ logger(f"----------------------------------------------------------")
+
+
+######################################################################
+
+import qmlp
+
+
+class QMLP(Task):
+ ######################
+
+ def __init__(
+ self,
+ nb_train_samples,
+ nb_test_samples,
+ batch_size,
+ result_dir,
+ logger=None,
+ device=torch.device("cpu"),
+ ):
+ super().__init__()
+
+ self.device = device
+ self.batch_size = batch_size
+ self.nb_samples_per_mlp = 256
+
+ if logger is not None:
+ logger(
+ f"generating {nb_train_samples+nb_test_samples} samples (can take some time)"
+ )
+
+ seq, q_test_set, test_error = qmlp.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,
+ )
+
+ self.train_input = seq[:nb_train_samples]
+ self.train_q_test_set = q_test_set[:nb_train_samples]
+ self.train_ref_test_errors = test_error[:nb_train_samples]
+ self.test_input = seq[nb_train_samples:]
+ self.test_q_test_set = q_test_set[nb_train_samples:]
+ self.test_ref_test_errors = test_error[nb_train_samples:]
+
+ filename = os.path.join(result_dir, f"train_errors_ref.dat")
+ with open(filename, "w") as f:
+ for e in self.train_ref_test_errors:
+ f.write(f"{e}\n")
+
+ filename = os.path.join(result_dir, f"test_errors_ref.dat")
+ with open(filename, "w") as f:
+ for e in self.test_ref_test_errors:
+ f.write(f"{e}\n")
+
+ 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
+ for batch in tqdm.tqdm(
+ input.split(self.batch_size), dynamic_ncols=True, desc=f"epoch-{split}"
+ ):
+ yield batch
+
+ def vocabulary_size(self):
+ return self.nb_codes
+
+ def produce_results(
+ self, n_epoch, model, result_dir, logger, deterministic_synthesis
+ ):
+ correct = self.test_input[:1000]
+ result = correct.clone()
+ ar_mask = (
+ torch.arange(result.size(1), device=result.device)
+ > self.nb_samples_per_mlp * 3 + 1
+ ).long()[None, :]
+ ar_mask = ar_mask.expand_as(result)
+ result *= 1 - ar_mask # paraaaaanoiaaaaaaa
+
+ masked_inplace_autoregression(
+ model,
+ self.batch_size,
+ result,
+ ar_mask,
+ deterministic_synthesis,
+ device=self.device,
+ )
+
+ q_train_set = result[:, : self.nb_samples_per_mlp * 3]
+ q_params = result[:, self.nb_samples_per_mlp * 3 + 1 :]
+ error_test = qmlp.evaluate_q_params(q_params, self.test_q_test_set)
+
+ filename = os.path.join(result_dir, f"test_errors_{n_epoch:04d}.dat")
+ with open(filename, "w") as f:
+ for e in error_test:
+ f.write(f"{e}\n")
+
+
+######################################################################
+
+import greed
+
+
+class Greed(Task):
+ def __init__(
+ self,
+ nb_train_samples,
+ nb_test_samples,
+ batch_size,
+ height,
+ width,
+ T,
+ nb_walls,
+ nb_coins,
+ logger=None,
+ device=torch.device("cpu"),
+ ):
+ super().__init__()
+
+ self.batch_size = batch_size
+ self.device = device
+
+ self.world = greed.GreedWorld(height, width, T, nb_walls, nb_coins)
+
+ states, actions, rewards = self.world.generate_episodes(
+ nb_train_samples + nb_test_samples
+ )
+ seq = self.world.episodes2seq(states, actions, rewards)
+ self.train_input = seq[:nb_train_samples].to(self.device)
+ self.test_input = seq[nb_train_samples:].to(self.device)
+
+ def wipe_lookahead_rewards(self, batch):
+ t = torch.arange(batch.size(1), device=batch.device)[None, :]
+ u = torch.randint(batch.size(1), (batch.size(0), 1), device=batch.device)
+ lr_mask = (t <= u).long() * (
+ t % self.world.it_len == self.world.index_lookahead_reward
+ ).long()
+
+ return (
+ lr_mask * self.world.lookahead_reward2code(greed.REWARD_UNKNOWN)
+ + (1 - lr_mask) * batch
+ )
+
+ 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 self.wipe_lookahead_rewards(batch)
+
+ def vocabulary_size(self):
+ return self.world.nb_codes
+
+ def thinking_autoregression(
+ self, n_epoch, model, result_dir, logger, deterministic_synthesis, nmax=1000
+ ):
+ snapshots = []
+
+ def ar(result, ar_mask, logit_biases=None):
+ ar_mask = ar_mask.expand_as(result)
+ result *= 1 - ar_mask
+ masked_inplace_autoregression(
+ model,
+ self.batch_size,
+ result,
+ ar_mask,
+ deterministic_synthesis=deterministic_synthesis,
+ logit_biases=logit_biases,
+ device=self.device,
+ progress_bar_desc=None,
+ )
+ warnings.warn("keeping thinking snapshots", RuntimeWarning)
+ snapshots.append(result[:100].detach().clone())
+
+ # Generate iteration after iteration
+
+ result = self.test_input[:250].clone()
+ # Erase all the content but that of the first iteration
+ result[:, self.world.it_len :] = -1
+ # Set the lookahead_reward of the firs to UNKNOWN
+ result[:, self.world.index_lookahead_reward] = self.world.lookahead_reward2code(
+ greed.REWARD_UNKNOWN
+ )
+
+ t = torch.arange(result.size(1), device=result.device)[None, :]
+
+ for u in tqdm.tqdm(
+ range(0, result.size(1), self.world.it_len),
+ desc="thinking",
+ ):
+ # Generate the next state but keep the initial one, the
+ # lookahead_reward of previous iterations are set to
+ # UNKNOWN
+ if u > 0:
+ result[
+ :, u + self.world.index_lookahead_reward
+ ] = self.world.lookahead_reward2code(greed.REWARD_UNKNOWN)
+ ar_mask = (t >= u + self.world.index_states).long() * (
+ t < u + self.world.index_states + self.world.state_len
+ ).long()
+ ar(result, ar_mask)
+
+ # Generate the action and reward with lookahead_reward to +1
+ result[
+ :, u + self.world.index_lookahead_reward
+ ] = self.world.lookahead_reward2code(greed.REWARD_PLUS)
+ ar_mask = (t >= u + self.world.index_reward).long() * (
+ t <= u + self.world.index_action
+ ).long()
+ ar(result, ar_mask)
+
+ # Set the lookahead_reward to UNKNOWN for the next iterations
+ result[
+ :, u + self.world.index_lookahead_reward
+ ] = self.world.lookahead_reward2code(greed.REWARD_UNKNOWN)
+
+ filename = os.path.join(result_dir, f"test_thinking_compute_{n_epoch:04d}.txt")
+ with open(filename, "w") as f:
+ for n in range(snapshots[0].size(0)):
+ for s in snapshots:
+ lr, s, a, r = self.world.seq2episodes(
+ s[n : n + 1],
+ )
+ str = self.world.episodes2str(
+ lr, s, a, r, unicode=True, ansi_colors=True
+ )
+ f.write(str)
+ f.write("\n\n")
+
+ # Saving the generated sequences
+
+ lr, s, a, r = self.world.seq2episodes(result)
+ str = self.world.episodes2str(lr, s, a, r, unicode=True, ansi_colors=True)
+
+ filename = os.path.join(result_dir, f"test_thinking_seq_{n_epoch:04d}.txt")
+ with open(filename, "w") as f:
+ f.write(str)
+ logger(f"wrote {filename}")
+
+ def produce_results(
+ self, n_epoch, model, result_dir, logger, deterministic_synthesis, nmax=1000
+ ):
+ result = self.wipe_lookahead_rewards(self.test_input[:250].clone())
+
+ # Saving the ground truth
+
+ lr, s, a, r = self.world.seq2episodes(
+ result,
+ )
+ str = self.world.episodes2str(lr, s, a, r, unicode=True, ansi_colors=True)
+
+ filename = os.path.join(result_dir, f"test_true_seq_{n_epoch:04d}.txt")
+ with open(filename, "w") as f:
+ f.write(str)
+ logger(f"wrote {filename}")
+
+ # Re-generating from the first frame
+
+ ar_mask = (
+ torch.arange(result.size(1), device=result.device) >= self.world.it_len
+ ).long()[None, :]
+ ar_mask = ar_mask.expand_as(result)
+ result *= 1 - ar_mask # paraaaaanoiaaaaaaa
+
+ masked_inplace_autoregression(
+ model,
+ self.batch_size,
+ result,
+ ar_mask,
+ deterministic_synthesis,
+ device=self.device,
+ )
+
+ # Saving the generated sequences
+
+ lr, s, a, r = self.world.seq2episodes(
+ result,
+ )
+ str = self.world.episodes2str(lr, s, a, r, unicode=True, ansi_colors=True)
+
+ filename = os.path.join(result_dir, f"test_seq_{n_epoch:04d}.txt")
+ with open(filename, "w") as f:
+ f.write(str)
+ logger(f"wrote {filename}")
+
+ self.thinking_autoregression(
+ n_epoch, model, result_dir, logger, deterministic_synthesis, nmax
+ )
+
+
+######################################################################
+######################################################################
+
+import world
+
+
+class World(Task):
+ def save_image(self, input, result_dir, filename, logger):
+ img = world.sample2img(self.train_input.to("cpu"), self.height, self.width)
+ image_name = os.path.join(result_dir, filename)
+ torchvision.utils.save_image(img.float() / 255.0, image_name, nrow=8, padding=2)
+ logger(f"wrote {image_name}")
+
+ def __init__(
+ self,
+ nb_train_samples,
+ nb_test_samples,
+ batch_size,
+ result_dir=None,
+ logger=None,
+ device=torch.device("cpu"),
+ ):
+ super().__init__()
+
+ self.batch_size = batch_size
+ self.device = device
+ self.height = 6
+ self.width = 8
+
+ self.train_input = world.generate(
+ nb_train_samples, height=self.height, width=self.width
+ )
+ self.train_ar_mask = (
+ (torch.arange(self.train_input.size(1)) > self.train_input.size(1) // 2)
+ .long()[None, :]
+ .expand_as(self.train_input)
+ )
+
+ self.test_input = world.generate(
+ nb_test_samples, height=self.height, width=self.width
+ )
+ self.test_ar_mask = (
+ (torch.arange(self.test_input.size(1)) > self.test_input.size(1) // 2)
+ .long()[None, :]
+ .expand_as(self.test_input)
+ )
+
+ self.train_input, self.train_ar_mask = self.train_input.to(
+ device
+ ), self.train_ar_mask.to(device)
+ self.test_input, self.test_ar_mask = self.test_input.to(
+ device
+ ), self.test_ar_mask.to(device)
+
+ self.nb_codes = max(self.train_input.max(), self.test_input.max()) + 1
+
+ if result_dir is not None:
+ self.save_image(
+ self.train_input[:96], result_dir, f"world_train.png", logger
+ )
+
+ 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, result_dir, logger, deterministic_synthesis, nmax=1000
+ ):
+ def compute_accuracy(input, ar_mask, logger=None):
+ input, ar_mask = input[:nmax], ar_mask[:nmax]
+ result = input.clone() * (1 - ar_mask)
+
+ masked_inplace_autoregression(
+ model,
+ self.batch_size,
+ result,
+ ar_mask,
+ deterministic_synthesis,
+ progress_bar_desc=None,
+ device=self.device,
+ )
+
+ nb_total, nb_correct = (
+ input.size(0),
+ (input == result).long().min(dim=1).values.sum(),
+ )
+
+ return nb_total, nb_correct
+
+ train_nb_total, train_nb_correct = compute_accuracy(
+ self.train_input, self.train_ar_mask
+ )
+
+ logger(
+ 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 = compute_accuracy(
+ self.test_input, self.test_ar_mask, logger
+ )
+
+ logger(
+ 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}%"
+ )
+
+ logger(f"main_test_accuracy {n_epoch} {test_nb_correct/test_nb_total}")
+
+ ##############################
+
+ input, ar_mask = self.test_input[:96], self.test_ar_mask[:96]
+ result = input.clone() * (1 - ar_mask)
+
+ masked_inplace_autoregression(
+ model,
+ self.batch_size,
+ result,
+ ar_mask,
+ deterministic_synthesis,
+ progress_bar_desc=None,
+ device=self.device,
+ )
+
+ self.save_image(result, result_dir, f"world_result_{n_epoch:04d}.png", logger)
+
+ def store_new_problems(self, new_problems):
+ nb_current = self.train_input.size(0)
+ nb_new = new_problems.size(0)
+ if nb_new >= nb_current:
+ self.train_input[...] = new_problems[:nb_current]
+ else:
+ nb_kept = nb_current - nb_new
+ self.train_input[:nb_kept] = self.train_input[-nb_kept:].clone()
+ self.train_input[nb_kept:] = new_problems
+
+ def create_new_problems(self, n_epoch, result_dir, logger, nb, model, nb_runs):
+ new_problems = torch.empty(
+ nb, self.height * self.width * 2 + 1, device=self.device, dtype=torch.int64
+ )
+ ar_mask = torch.full(new_problems.size(), 1, device=self.device)
+
+ masked_inplace_autoregression(
+ model,
+ self.batch_size,
+ new_problems,
+ ar_mask,
+ deterministic_synthesis=False,
+ progress_bar_desc="new problems",
+ device=self.device,
+ )
+
+ nb_correct = torch.empty(nb, device=self.device, dtype=torch.int64)
+
+ for n in tqdm.tqdm(
+ range(new_problems.size(0)), dynamic_ncols=True, desc="checking problems"
+ ):
+ result = new_problems[n][None, :].expand(nb_runs, -1).clone()
+ ar_mask = (
+ (torch.arange(result.size(1), device=self.device) > result.size(1) // 2)
+ .long()[None, :]
+ .expand_as(result)
+ )
+
+ masked_inplace_autoregression(
+ model,
+ self.batch_size,
+ result,
+ ar_mask,
+ deterministic_synthesis=False,
+ progress_bar_desc=None,
+ device=self.device,
+ )
+
+ nb_correct[n] = (
+ (new_problems[n][None, :] == result).long().min(dim=1).values.sum()
+ )
+
+ return new_problems, nb_correct