+######################################################################
+
+
+class Problem:
+ def generate(nb):
+ pass
+
+ def perf(seq, logger):
+ pass
+
+
+class ProblemByheart(Problem):
+ def __init__(self):
+ nb_seq, len_prompt, len_result = 100, 5, 5
+ self.seq = torch.randint(10, (nb_seq, len_prompt + 1 + len_result))
+ self.seq[:,len_prompt]=-1
+
+ def generate_sequences(self, nb):
+ return self.seq[torch.randint(self.seq.size(0), (nb,))]
+
+class SandBox(Task):
+ def __init__(
+ self,
+ nb_train_samples,
+ nb_test_samples,
+ batch_size,
+ logger=None,
+ device=torch.device("cpu"),
+ ):
+ super().__init__()
+
+ self.batch_size = batch_size
+
+ problems = [ ProblemByheart() ]
+ nb_common_codes = 100
+
+ def generate_sequences(nb_samples):
+ problem_indexes = torch.randint(len(problems), (nb_samples,))
+ nb_samples_per_problem = torch.one_hot(problem_indexes).sum(0)
+ print(f"{nb_samples_per_problem}")
+ all_seq = []
+ for nb, p in zip(nb_samples_per_problem,problems):
+ all_seq.append(p.generate_sequences(nb_samples_per_problem[nb]))
+ return all_seq
+
+ train_seq = generate_sequences(nb_train_samples)
+ test_seq = generate_sequences(nb_test_samples)
+
+ for strain, stest in zip(train_seq, test_seq):
+ s = torch.cat((strain,stest),0)
+
+ 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, result_dir, logger, deterministic_synthesis
+ ):
+ # 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}%"
+ # )
+ pass
+
+