+ 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 escape
+
+
+class Escape(Task):
+ def __init__(
+ self,
+ nb_train_samples,
+ nb_test_samples,
+ batch_size,
+ height,
+ width,
+ T,
+ logger=None,
+ device=torch.device("cpu"),
+ ):
+ super().__init__()
+
+ self.batch_size = batch_size
+ self.device = device
+ self.height = height
+ self.width = width
+
+ states, actions, rewards = escape.generate_episodes(
+ nb_train_samples + nb_test_samples, height, width, 3 * T
+ )
+ seq = escape.episodes2seq(states, actions, rewards, lookahead_delta=T)
+ seq = seq[:, seq.size(1) // 3 : 2 * seq.size(1) // 3]
+ self.train_input = seq[:nb_train_samples].to(self.device)
+ self.test_input = seq[nb_train_samples:].to(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
+
+ def thinking_autoregression(
+ self, n_epoch, model, result_dir, logger, deterministic_synthesis, nmax=1000
+ ):
+ result = self.test_input[:100].clone()
+ t = torch.arange(result.size(1), device=result.device)
+ itl = self.height * self.width + 3
+
+ def ar():
+ masked_inplace_autoregression(
+ model,
+ self.batch_size,
+ result,
+ ar_mask,
+ deterministic_synthesis,
+ device=self.device,
+ )
+
+ for u in range(itl, result.size(1) - itl + 1, itl):
+ print(f"{itl=} {u=} {result.size(1)=}")
+ result[:, u - 1] = (-1) + 1 + escape.first_lookahead_rewards_code
+ ar_mask = (t >= u).long() * (t < u + self.height * self.width).long()
+ ar_mask = ar_mask[None, :]
+ ar_mask = ar_mask.expand_as(result)
+ result *= 1 - ar_mask
+ ar()
+ result[:, u - 1] = (1) + 1 + escape.first_lookahead_rewards_code
+ ar_mask = (t >= self.height * self.width).long() * (
+ t < self.height * self.width + 2
+ ).long()
+ ar_mask = ar_mask[None, :]
+ ar_mask = ar_mask.expand_as(result)
+ result *= 1 - ar_mask
+ ar()
+
+ # Saving the generated sequences
+
+ s, a, r, lr = escape.seq2episodes(
+ result, self.height, self.width, lookahead=True
+ )
+ str = escape.episodes2str(
+ s, a, r, lookahead_rewards=lr, 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.test_input[:100].clone()
+
+ # Saving the ground truth
+
+ s, a, r, lr = escape.seq2episodes(
+ result, self.height, self.width, lookahead=True
+ )
+ str = escape.episodes2str(
+ s, a, r, lookahead_rewards=lr, 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.height * self.width + 3
+ ).long()[None, :]
+ ar_mask = ar_mask.expand_as(result)
+ result *= 1 - ar_mask # paraaaaanoiaaaaaaa