Update.

[culture.git] / quizz_machine.py

diff --git a/quizz_machine.py b/quizz_machine.py
index 6f7492d..3828e5b 100755 (executable)
--- a/quizz_machine.py
+++ b/quizz_machine.py
@@ -17,43 +17,6 @@ from mygpt import BracketedSequence
 
 ######################################################################
 
 
 ######################################################################
 

-
-class Gang(nn.Module):
-    def __init__(self, models, nb_models_for_generation, mode="groupthink"):
-        super().__init__()
-        self.models = nn.ModuleList(models)
-        self.nb_models_for_generation = nb_models_for_generation
-        self.mode = mode
-
-    def forward(self, bs):
-        # If first = 0, we are re-starting an auto-regressive process,
-        # that's the right moment to randomize who gonna do it
-        if bs.first == 0:
-            self.models_to_use = [
-                self.models[k]
-                for k in torch.randperm(len(self.models))[
-                    : self.nb_models_for_generation
-                ]
-            ]
-
-        all_the_logits = torch.cat(
-            [model(bs).x[None] for model in self.models_to_use], dim=0
-        )
-
-        if self.mode == "groupthink":
-            y = all_the_logits.mean(dim=0)
-        elif self.mode == "groupwork":
-            m = torch.rand(all_the_logits.size(), device=all_the_logits.device)
-            m = (m.sort(dim=0).indices == 0).long()
-            y = (y * m).sum(dim=0)
-        else:
-            raise ValueError(f"Invalid mode {self.mode}")
-
-        return BracketedSequence(y, bs.first, bs.nb)
-
-
-######################################################################
-

 # ar_mask is a tensor with 0s and 1s, of same shape as input, with
 # 1s where tokens should be generated. The others are kept
 # unchanged.
 # ar_mask is a tensor with 0s and 1s, of same shape as input, with
 # 1s where tokens should be generated. The others are kept
 # unchanged.


@@ -66,8 +29,6 @@ def one_batch_masked_inplace_autoregression(
     seq_logproba,
     temperature=1.0,
     deterministic_synthesis=False,
     seq_logproba,
     temperature=1.0,
     deterministic_synthesis=False,

-    forbidden_tokens=None,
-    forced_biases=None,

 ):
     to_generate = (ar_mask.sum(0) > 0).nonzero()
 
 ):
     to_generate = (ar_mask.sum(0) > 0).nonzero()
 


@@ -82,12 +43,6 @@ def one_batch_masked_inplace_autoregression(
 
         logits = (logits / temperature).log_softmax(dim=-1)
 
 
         logits = (logits / temperature).log_softmax(dim=-1)
 

-        if forbidden_tokens is not None:
-            logits = logits.masked_fill(forbidden_tokens, float("-inf"))
-
-        if forced_biases is not None:
-            logits = logits + forced_biases[None, :]
-

         if deterministic_synthesis:
             t_next = logits.argmax(-1)
         else:
         if deterministic_synthesis:
             t_next = logits.argmax(-1)
         else:


@@ -141,8 +96,6 @@ def masked_inplace_autoregression(
                 seq_logproba=seq_logproba,
                 temperature=temperature,
                 deterministic_synthesis=deterministic_synthesis,
                 seq_logproba=seq_logproba,
                 temperature=temperature,
                 deterministic_synthesis=deterministic_synthesis,

-                forbidden_tokens=forbidden_tokens,
-                forced_biases=logit_biases,

             )
 
         model.train(t)
             )
 
         model.train(t)


@@ -152,9 +105,99 @@ def masked_inplace_autoregression(
 
 
 class QuizzMachine:
 
 
 class QuizzMachine:

-    def make_ar_mask(self, input):
-        b = torch.arange(input.size(1), device=input.device) > input.size(1) // 2
-        return b.long()[None, :].expand_as(input)
+    def indices_forward_and_backward(self, quizzes):
+        i_forward = quizzes[:, 0] == self.token_forward
+        j_forward = quizzes[:, 1 + self.prompt_len] == self.token_forward
+        i_backward = quizzes[:, 0] == self.token_backward
+        j_backward = quizzes[:, 1 + self.answer_len] == self.token_backward
+        assert torch.logical_or(
+            torch.logical_and(i_forward, j_forward),
+            torch.logical_and(i_backward, j_backward),
+        ).all()
+        return i_forward, i_backward
+
+    def reverse_time(self, quizzes):
+        i_forward, i_backward = self.indices_forward_and_backward(quizzes)
+
+        forward_to_backward = torch.cat(
+            [
+                quizzes[:, 0:1],
+                quizzes[:, 2 + self.prompt_len :],
+                quizzes[:, 1 + self.prompt_len : 2 + self.prompt_len],
+                quizzes[:, 1 : 1 + self.prompt_len],
+            ],
+            dim=1,
+        )
+        forward_to_backward[:, 0] = self.token_backward
+        forward_to_backward[:, 1 + self.answer_len] = self.token_backward
+
+        backward_to_forward = torch.cat(
+            [
+                quizzes[:, 0:1],
+                quizzes[:, 2 + self.answer_len :],
+                quizzes[:, 1 + self.answer_len : 2 + self.answer_len],
+                quizzes[:, 1 : 1 + self.answer_len],
+            ],
+            dim=1,
+        )
+
+        backward_to_forward[:, 0] = self.token_forward
+        backward_to_forward[:, 1 + self.prompt_len] = self.token_forward
+
+        m = i_forward.long()[:, None]
+
+        return m * forward_to_backward + (1 - m) * backward_to_forward
+
+    def make_ar_mask(self, quizzes, first=False):
+        i_forward, i_backward = self.indices_forward_and_backward(quizzes)
+
+        t = torch.arange(quizzes.size(1), device=quizzes.device)
+
+        if first:
+            m_forward = (t >= 1).long() * (t < 1 + self.prompt_len).long()
+            m_backward = (t >= 1).long() * (t < 1 + self.answer_len).long()
+        else:
+            m_forward = (t >= 2 + self.prompt_len).long()
+            m_backward = (t >= 2 + self.answer_len).long()
+
+        m = i_forward.long()[:, None]
+
+        return m * m_forward + (1 - m) * m_backward
+
+    def generate_token_sequences(self, nb):
+        prompts, answers = self.problem.generate_prompts_and_answers(nb)
+
+        print(f"{prompts.size()=} {answers.size()=}")
+
+        if self.prompt_len is None:
+            self.prompt_len = prompts.size(1)
+
+        if self.answer_len is None:
+            self.answer_len = answers.size(1)
+
+        assert prompts.size(1) == self.prompt_len and answers.size(1) == self.answer_len
+
+        result = []
+
+        for prompt, answer in zip(prompts, answers):
+            if torch.rand(1) < 0.5:
+                a = [
+                    torch.tensor([self.token_forward]),
+                    prompt,
+                    torch.tensor([self.token_forward]),
+                    answer,
+                ]
+            else:
+                a = [
+                    torch.tensor([self.token_backward]),
+                    answer,
+                    torch.tensor([self.token_backward]),
+                    prompt,
+                ]
+
+            result.append(torch.cat(a, dim=0)[None, :])
+
+        return torch.cat(result, dim=0)

 
     def __init__(
         self,
 
     def __init__(
         self,


@@ -168,28 +211,59 @@ class QuizzMachine:
     ):
         super().__init__()
 
     ):
         super().__init__()
 

+        v = problem.nb_token_values()
+        self.token_forward = v
+        self.token_backward = v + 1
+        self.nb_token_values = v + 2
+

         self.problem = problem
         self.batch_size = batch_size
         self.device = device
         self.logger = logger
         self.problem = problem
         self.batch_size = batch_size
         self.device = device
         self.logger = logger

+        self.prompt_len = None
+        self.answer_len = None

 
 

-        self.train_w_quizzes = self.problem.generate_token_sequences(
-            nb_train_samples
-        ).to(device)
-        self.test_w_quizzes = self.problem.generate_token_sequences(nb_test_samples).to(
+        self.train_w_quizzes = self.generate_token_sequences(nb_train_samples).to(

             device
         )
 
             device
         )
 

-        self.nb_codes = max(self.train_w_quizzes.max(), self.test_w_quizzes.max()) + 1
+        self.test_w_quizzes = self.generate_token_sequences(nb_test_samples).to(device)

 
         self.train_c_quizzes = []
         self.test_c_quizzes = []
 
         if result_dir is not None:
 
         self.train_c_quizzes = []
         self.test_c_quizzes = []
 
         if result_dir is not None:

-            self.problem.save_quizzes(
-                self.train_w_quizzes[:72], result_dir, "culture_w_quizzes"
+            self.save_quizzes(
+                result_dir, "culture_w_quizzes", self.train_w_quizzes[:72]

             )
 
             )
 

+            # toto = self.reverse_time(self.train_w_quizzes[:72])
+            # self.save_quizzes(result_dir, "toto", toto)
+            # exit(0)
+
+    def save_quizzes(self, result_dir, filename_prefix, quizzes, prediction=False):
+        forward = quizzes[quizzes[:, 0] == self.token_forward]
+        ib = quizzes[:, 0] == self.token_backward
+        backward = quizzes[ib]
+        assert forward.size(0) + backward.size(0) == quizzes.size(0)
+        quizzes[ib] = self.reverse_time(quizzes[ib])
+
+        if prediction:
+            predicted_prompts = ib
+            predicted_answers = torch.logical_not(ib)
+        else:
+            predicted_prompts = None
+            predicted_answers = None
+
+        self.problem.save_quizzes(
+            result_dir,
+            filename_prefix,
+            quizzes[:, 1 : 1 + self.prompt_len],
+            quizzes[:, 2 + self.prompt_len :],
+            predicted_prompts,
+            predicted_answers,
+        )
+

     def batches(self, split="train", desc=None):
         assert split in {"train", "test"}
         if split == "train":
     def batches(self, split="train", desc=None):
         assert split in {"train", "test"}
         if split == "train":


@@ -230,7 +304,7 @@ class QuizzMachine:
             yield batch
 
     def vocabulary_size(self):
             yield batch
 
     def vocabulary_size(self):

-        return self.nb_codes
+        return self.nb_token_values

 
     def produce_results(
         self, n_epoch, model, result_dir, deterministic_synthesis, nmax=1000
 
     def produce_results(
         self, n_epoch, model, result_dir, deterministic_synthesis, nmax=1000


@@ -253,10 +327,8 @@ class QuizzMachine:
                 device=self.device,
             )
 
                 device=self.device,
             )
 

-            nb_total, nb_correct = (
-                input.size(0),
-                (input == result).long().min(dim=1).values.sum(),
-            )
+            nb_total = input.size(0)
+            nb_correct = (input == result).long().min(dim=1).values.sum()

 
             return nb_total, nb_correct
 
 
             return nb_total, nb_correct
 


@@ -294,8 +366,11 @@ class QuizzMachine:
             device=self.device,
         )
 
             device=self.device,
         )
 

-        self.problem.save_quizzes(
-            result[:72], result_dir, f"culture_prediction_{n_epoch:04d}_{model.id:02d}"
+        self.save_quizzes(
+            result_dir,
+            f"culture_prediction_{n_epoch:04d}_{model.id:02d}",
+            quizzes=result[:72],
+            prediction=True,

         )
 
         return main_test_accuracy
         )
 
         return main_test_accuracy


@@ -304,7 +379,7 @@ class QuizzMachine:
         input = self.train_w_quizzes if for_train else self.test_w_quizzes
         nb = min(nb, input.size(0))
         input[:-nb] = input[nb:].clone()
         input = self.train_w_quizzes if for_train else self.test_w_quizzes
         nb = min(nb, input.size(0))
         input[:-nb] = input[nb:].clone()

-        input[-nb:] = self.problem.generate_token_sequences(nb).to(self.device)
+        input[-nb:] = self.generate_token_sequences(nb).to(self.device)

 
     def store_c_quizzes(self, new_c_quizzes, for_train=True):
         if for_train:
 
     def store_c_quizzes(self, new_c_quizzes, for_train=True):
         if for_train:


@@ -312,180 +387,126 @@ class QuizzMachine:
         else:
             self.test_c_quizzes.append(new_c_quizzes)
 
         else:
             self.test_c_quizzes.append(new_c_quizzes)
 

-    def reverse_time(self, c_quizzes):
-        token_forward, token_backward = self.problem.direction_tokens()
-
-        l = (c_quizzes.size(1) - 1) // 2
-        direction = c_quizzes[:, l : l + 1]
-        direction = self.problem.token_forward * (
-            direction == self.problem.token_backward
-        ) + self.problem.token_backward * (direction == self.problem.token_forward)
-
-        return torch.cat([c_quizzes[:, l + 1 :], direction, c_quizzes[:, :l]], dim=1)
-
-    def comput_correctness(self, c_quizzes, models_for_validation):
-        reversed_c_quizzes = self.reverse_time(c_quizzes)
-
-        ar_mask = self.make_ar_mask(c_quizzes)
-        seq_logproba = torch.empty(ar_mask.size(0), device=self.device)
+    def compute_correctness(
+        self,
+        c_quizzes,
+        models_for_validation,
+        bidirectional_validation=False,
+        deterministic_validation=True,
+    ):
+        if bidirectional_validation:
+            backward_c_quizzes = self.forward_to_backward(c_quizzes)

 
 

-        # Check how many of models can solve the quizzes in both directions
+        seq_logproba = torch.zeros(
+            c_quizzes.size(0),
+            max([m.id for m in models_for_validation]) + 1,
+            device=self.device,
+        )

 
         nb_correct = 0
 
         for model in models_for_validation:
             result = c_quizzes.clone()
 
 
         nb_correct = 0
 
         for model in models_for_validation:
             result = c_quizzes.clone()
 

+            seq_logproba[...] = 0.0
+
+            ar_mask = self.make_ar_mask(result)
+

             masked_inplace_autoregression(
                 model=model,
                 batch_size=self.batch_size,
                 input=result,
                 ar_mask=ar_mask,
             masked_inplace_autoregression(
                 model=model,
                 batch_size=self.batch_size,
                 input=result,
                 ar_mask=ar_mask,

-                seq_logproba=seq_logproba,
+                seq_logproba=seq_logproba[:, model.id],

                 temperature=1.0,
                 temperature=1.0,

-                deterministic_synthesis=True,
+                deterministic_synthesis=deterministic_validation,

                 # progress_bar_desc="solving c_quizzes",
                 device=self.device,
             )
 
             correct = (c_quizzes == result).long().min(dim=-1).values
 
                 # progress_bar_desc="solving c_quizzes",
                 device=self.device,
             )
 
             correct = (c_quizzes == result).long().min(dim=-1).values
 

-            reversed_result = reversed_c_quizzes.clone()
+            if bidirectional_validation:
+                backward_result = backward_c_quizzes.clone()

 
 

-            masked_inplace_autoregression(
-                model=model,
-                batch_size=self.batch_size,
-                input=reversed_result,
-                ar_mask=ar_mask,
-                seq_logproba=seq_logproba,
-                temperature=1.0,
-                deterministic_synthesis=True,
-                # progress_bar_desc="solving reversed c_quizzes",
-                device=self.device,
-            )
+                ar_mask = self.make_ar_mask(backward_result)

 
 

-            reversed_correct = (
-                (reversed_c_quizzes == reversed_result).long().min(dim=-1).values
-            )
+                masked_inplace_autoregression(
+                    model=model,
+                    batch_size=self.batch_size,
+                    input=backward_result,
+                    ar_mask=ar_mask,
+                    seq_logproba=seq_logproba[:, model.id],
+                    temperature=1.0,
+                    deterministic_synthesis=deterministic_validation,
+                    # progress_bar_desc="solving backward c_quizzes",
+                    device=self.device,
+                )
+
+                backward_correct = (
+                    (backward_c_quizzes == backward_result).long().min(dim=-1).values
+                )
+
+                correct *= backward_correct
+
+            # endif

 
 

-            nb_correct += correct * reversed_correct
+            nb_correct += correct

 
 

-        return nb_correct
+        return nb_correct, seq_logproba

 
     ###############################################################
 
 
     ###############################################################
 

-    def generate_quizzes(
-        self, nb, model_for_generation, min_ave_seq_logproba, reverse_cleanup=False
-    ):
+    def generate_quizzes(self, nb, model_for_generation, temperature=1.0):

         c_quizzes = torch.empty(
             nb, self.train_w_quizzes.size(1), device=self.device, dtype=torch.int64
         )
 
         c_quizzes = torch.empty(
             nb, self.train_w_quizzes.size(1), device=self.device, dtype=torch.int64
         )
 

-        ar_mask_prompt = torch.zeros(c_quizzes.size(), device=self.device)
-        ar_mask_prompt[:, : ar_mask_prompt.size(1) // 2 + 1] = 1
-        ar_mask_solve = 1 - ar_mask_prompt
-        seq_logproba = torch.empty(ar_mask_prompt.size(0), device=self.device)
-
-        if reverse_cleanup:
-            warnings.warn("very high temperature with reversed cleanup", RuntimeWarning)
-            temperature = 10.0
-        else:
-            temperature = 1.0
+        seq_logproba = torch.zeros(nb, device=self.device)

 
 

-        # warnings.warn("noise injection", RuntimeWarning)
-        # noise_std = torch.rand(1).item()
-        # self.logger(f"{noise_std=}")
+        # First, we generate the answer at high temperature

 
 

-        # mygpt.set_noise_injection(model_for_generation, noise_std)
+        c_quizzes[:, 0] = self.token_backward
+        c_quizzes[:, 1 + self.answer_len] = self.token_backward

 
         masked_inplace_autoregression(
             model=model_for_generation,
             batch_size=self.batch_size,
             input=c_quizzes,
 
         masked_inplace_autoregression(
             model=model_for_generation,
             batch_size=self.batch_size,
             input=c_quizzes,

-            ar_mask=ar_mask_prompt,
+            ar_mask=self.make_ar_mask(c_quizzes, first=True),

             seq_logproba=seq_logproba,
             temperature=temperature,
             deterministic_synthesis=False,
             seq_logproba=seq_logproba,
             temperature=temperature,
             deterministic_synthesis=False,

-            # progress_bar_desc="sampling c_quizzes",

             device=self.device,
         )
 
             device=self.device,
         )
 

-        # mygpt.set_noise_injection(model_for_generation, 0.0)
-
-        ave_seq_logproba = seq_logproba.mean()
+        # Then, we generate the prompt at low temperature

 
         masked_inplace_autoregression(
             model=model_for_generation,
             batch_size=self.batch_size,
             input=c_quizzes,
 
         masked_inplace_autoregression(
             model=model_for_generation,
             batch_size=self.batch_size,
             input=c_quizzes,

-            ar_mask=ar_mask_solve,
+            ar_mask=self.make_ar_mask(c_quizzes),

             seq_logproba=seq_logproba,
             seq_logproba=seq_logproba,

-            temperature=temperature,
-            deterministic_synthesis=True,
-            # progress_bar_desc="sampling c_quizzes",
+            temperature=1 / temperature,
+            deterministic_synthesis=False,

             device=self.device,
         )
 
             device=self.device,
         )
 

-        if reverse_cleanup:
-            c_quizzes = self.reverse_time(c_quizzes)
-            masked_inplace_autoregression(
-                model=model_for_generation,
-                batch_size=self.batch_size,
-                input=c_quizzes,
-                ar_mask=ar_mask_solve,
-                seq_logproba=seq_logproba,
-                temperature=temperature,
-                deterministic_synthesis=True,
-                # progress_bar_desc="sampling c_quizzes",
-                device=self.device,
-            )
-
-        return c_quizzes, seq_logproba.mean()
+        # Then we return the quizz, and re-generate the response, now
+        # at low temperature

 
 

-    ######################################################################
+        c_quizzes = self.reverse_time(c_quizzes)

 
 

-    def create_c_quizzes(
-        self,
-        nb,
-        model_for_generation,
-        models_for_validation,
-        min_ave_seq_logproba,
-        reverse_cleanup,
-        n_epoch,
-        result_dir,
-    ):
-        c_quizzes, ave_seq_logproba = self.generate_quizzes(
-            nb,
-            model_for_generation=model_for_generation,
-            min_ave_seq_logproba=min_ave_seq_logproba,
-            reverse_cleanup=reverse_cleanup,
+        masked_inplace_autoregression(
+            model=model_for_generation,
+            batch_size=self.batch_size,
+            input=c_quizzes,
+            ar_mask=self.make_ar_mask(c_quizzes),
+            seq_logproba=seq_logproba,
+            temperature=1 / temperature,
+            deterministic_synthesis=False,
+            device=self.device,

         )
 
         )
 

-        nb_correct = self.comput_correctness(c_quizzes, models_for_validation)
-
-        return c_quizzes, nb_correct, ave_seq_logproba
-
-    ######################################################################
-
-    def gang_create_c_quizzes(
-        self,
-        nb,
-        nb_models_for_generation,
-        models,
-        mode,
-        min_ave_seq_logproba,
-        reverse_cleanup,
-        n_epoch,
-        result_dir,
-    ):
-        model_for_generation = Gang(models, nb_models_for_generation, mode)
-        models_for_validation = models
-        return self.create_c_quizzes(
-            nb=nb,
-            model_for_generation=model_for_generation,
-            models_for_validation=models_for_validation,
-            min_ave_seq_logproba=min_ave_seq_logproba,
-            reverse_cleanup=reverse_cleanup,
-            n_epoch=n_epoch,
-            result_dir=result_dir,
-        )
+        return c_quizzes