Implementation nice and clean, but need to verify results w/ reference syntaxgym-core still

syntaxgym.py

@@ -13,8 +13,10 @@ import re
 from typing import List, Tuple
 
 import datasets
+from datasets import logging
 import numpy as np
 import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
 
 from .prediction import Prediction
 
@@ -64,26 +66,28 @@ class SyntaxGymSuiteConfig(datasets.BuilderConfig):
         self.features = list(suite_json["region_meta"].values())
 
 
+SUITE_DATASET_CONDITION_SPEC = {
+    "condition_name": datasets.Value("string"),
+    "content": datasets.Value("string"),
+    "regions": datasets.Sequence({
+        "region_number": datasets.Value("int32"),
+        "content": datasets.Value("string")
+    })
+}
+
+SUITE_DATASET_SPEC = {
+    "item_number": datasets.Value("int32"),
+    "conditions": datasets.Sequence(SUITE_DATASET_CONDITION_SPEC),
+    "predictions": datasets.Sequence(datasets.Value("string")),
+}
+
+
 class SyntaxGym(datasets.GeneratorBasedBuilder):
 
     BUILDER_CONFIGS = [SyntaxGymSuiteConfig(suite_json)
                        for suite_json in SUITE_JSONS.values()]
 
     def _info(self):
-        condition_spec = {
-            "condition_name": datasets.Value("string"),
-            "content": datasets.Value("string"),
-            "regions": datasets.Sequence({
-                "region_number": datasets.Value("int32"),
-                "content": datasets.Value("string")
-            })
-        }
-
-        features = {
-            "item_number": datasets.Value("int32"),
-            "conditions": datasets.Sequence(condition_spec)
-        }
-
         citation = ""
         if self.config.meta["reference"]:
             citation = f"Test suite citation: {self.meta['reference']}\n"
@@ -91,7 +95,7 @@ class SyntaxGym(datasets.GeneratorBasedBuilder):
 
         return datasets.DatasetInfo(
             description=_DESCRIPTION,
-            features=datasets.Features(features),
+            features=datasets.Features(SUITE_DATASET_SPEC),
             homepage=_PROJECT_URL,
             citation=citation,
         )
@@ -103,12 +107,15 @@ class SyntaxGym(datasets.GeneratorBasedBuilder):
     def _generate_examples(self, name):
         # DEV: NB suite jsons already loaded because BUILDER_CONFIGS is static
         suite_json = SUITE_JSONS[name]
+        predictions = [p["formula"] for p in suite_json["predictions"]]
 
         for item in suite_json["items"]:
             # Convert to sentence input.
             for cond in item["conditions"]:
                 cond["content"] = condition_to_string(cond)
 
+            item["predictions"] = predictions
+
             yield item["item_number"], item
 
 
@@ -117,27 +124,10 @@ class SyntaxGymMetric(datasets.Metric):
     SyntaxGym prediction evaluation metric.
     """
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.suite = SUITE_JSONS[self.config_name]
-        self.predictions = [
-            Prediction(idx, p["formula"], "sum")
-            for idx, p in enumerate(self.suite["predictions"])
-        ]
-
     def _info(self):
         seq = datasets.Sequence
         features = datasets.Features({
-            # surprisals: 3d float array
-            "surprisals": seq(seq(datasets.Value("float"))),
-
-            # TODO necessary? can assume it remains sorted?
-            "condition_names": datasets.Value("string"),
-
-            "input_ids": seq(datasets.Value("int32")),
-
-            # offset mapping: 3d int array
-            "offset_mapping": seq(seq(datasets.Value("int32"))),
+            "suite": SUITE_DATASET_SPEC
         })
         return datasets.MetricInfo(
             description="TODO",
@@ -146,16 +136,53 @@ class SyntaxGymMetric(datasets.Metric):
             features=features,
         )
 
-    def _compute(self, surprisals, item_number, condition_names,
-                 input_ids, offset_mapping):
-        # surprisals: B * T * V
-        surprisals = torch.tensor(surprisals)
-        assert surprisals.ndim == 3
+    def _compute(self, suite, model_id, batch_size: int = 16,
+                 add_start_token=True, device=None):
+        if device is not None:
+            assert device in ["gpu", "cpu", "cuda"]
+            if device == "gpu":
+                device = "cuda"
+        else:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        model = model.to(device)
+        model.eval()
+
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        # TODO copy from perplexity metric
+        tokenizer.pad_token = tokenizer.eos_token
+
+        results = {"prediction_results": [], "region_totals": []}
+        # TODO batch all items together
+        for item in logging.tqdm(suite):
+            result_single = self._compute_single(item, tokenizer, model, device)
+
+            for k in ["prediction_results", "region_totals"]:
+                results[k].append(result_single[k])
+
+        return results
+
+
+    def _compute_single(self, item, tokenizer, model, device):
+        tokenized = tokenizer(item["conditions"]["content"],
+                              padding=True,
+                              return_tensors="pt",
+                              return_offsets_mapping=True).to(device)
 
         # input_ids: B * T
-        input_ids = torch.tensor(input_ids)
+        input_ids = tokenized["input_ids"]
         assert input_ids.ndim == 2
 
+        # Compute sentence level surprisals.
+        with torch.no_grad():
+            # Pre-softmax predictive distribution B * T * V
+            logits = model(input_ids).logits
+            surprisals = -logits.log_softmax(dim=2) / np.log(2)
+
+        # surprisals: B * T * V
+        assert surprisals.ndim == 3
+
         # Get surprisals of expected words.
         surps_shifted = surprisals[:, :-1, :]
         expected_ids = input_ids[:, 1:]
@@ -170,10 +197,11 @@ class SyntaxGymMetric(datasets.Metric):
         # surprisals is now B * (T - 1)
 
         #### aggregate
+        condition_names = item["conditions"]["condition_name"]
         region_totals = {condition_name: defaultdict(float)
                          for condition_name in condition_names}
         region2tokens = self.compute_region_token_mapping(
-            item_number, condition_names, input_ids, offset_mapping)
+            item, input_ids, tokenized["offset_mapping"])
 
         for i, (i_cond, i_inputs) in enumerate(zip(condition_names, input_ids)):
             for region_number, region_tokens in region2tokens[i_cond].items():
@@ -183,7 +211,8 @@ class SyntaxGymMetric(datasets.Metric):
                     else:
                         # TODO don't think this is an issue, just should clean
                         # up the aggregation output
-                        print("Warning: exceeded ", token)
+                        assert token == surprisals.shape[1], \
+                            "%s %s" % (token, surprisals.shape[1])
 
         region_totals = {(condition_name, region_number): float(total)
                          for condition_name, totals in region_totals.items()
@@ -191,33 +220,29 @@ class SyntaxGymMetric(datasets.Metric):
 
         results = {
             "prediction_results": [
-                p.formula(region_totals) for p in self.predictions
+                Prediction(i, formula, "sum").formula(region_totals)
+                for i, formula in enumerate(item["predictions"])
             ],
 
             "region_totals": region_totals
         }
         return results
 
-    def get_region_edges(self, item_number, condition_name):
+    def get_region_edges(self, item, condition_idx):
         """
         Get left edge of each region as a character index.
         """
         # NB this is coupled with `condition_to_string` logic of course
 
-        # DEV bad, just reindex
-        item = next(item for item in self.suite["items"]
-                    if item["item_number"] == item_number)
-        cond = next(cond for cond in item["conditions"]
-                    if cond["condition_name"] == condition_name)
+        regions = item["conditions"]["regions"][condition_idx]
 
         idx = 0
         ret = []
-        for r_idx, region in enumerate(cond["regions"]):
+        for r_idx, region_content in enumerate(regions["content"]):
             ret.append(idx)
 
-            content = region["content"]
-            region_size = len(content)
-            if content.strip() != "" and r_idx != 0 and not content.startswith(","):
+            region_size = len(region_content)
+            if region_content.strip() != "" and r_idx != 0 and not region_content.startswith(","):
                 # Add joining space
                 region_size += 1
 
@@ -225,16 +250,20 @@ class SyntaxGymMetric(datasets.Metric):
 
         return ret
 
-    def compute_region_token_mapping(self, item_number, condition_names, input_ids,
+    def compute_region_token_mapping(self, item, input_ids: torch.LongTensor,
                                      offset_mapping: List[Tuple[int, int]]):
         # input_ids: B * T
         # offset_mapping: B * T * 2
+        # assumes batch is sorted according to item's condition_name order
 
+        condition_names = item["conditions"]["condition_name"]
         region2tokens = {cond: defaultdict(list) for cond in condition_names}
 
+        max_long = torch.iinfo(torch.int64).max
+
         input_ids = input_ids.detach()
-        for i_cond, i_tokens, i_offsets in zip(condition_names, input_ids, offset_mapping):
-            region_edges = self.get_region_edges(item_number, i_cond)
+        for i_cond, (i_tokens, i_offsets) in enumerate(zip(input_ids, offset_mapping)):
+            region_edges = self.get_region_edges(item, i_cond)
 
             t_cursor, r_cursor = 0, 0
             while t_cursor < i_tokens.shape[0]:
@@ -243,14 +272,14 @@ class SyntaxGymMetric(datasets.Metric):
 
                 region_start = region_edges[r_cursor]
                 region_end = region_edges[r_cursor + 1] \
-                    if r_cursor + 1 < len(region_edges) else np.inf
+                    if r_cursor + 1 < len(region_edges) else max_long
 
                 # NB region boundaries are left edges, hence the >= here.
                 if token_char_start >= region_end:
                     r_cursor += 1
                     continue
 
-                region2tokens[i_cond][r_cursor + 1].append(t_cursor)
+                region2tokens[condition_names[i_cond]][r_cursor + 1].append(t_cursor)
                 t_cursor += 1
 
         return region2tokens

test.py

@@ -7,44 +7,11 @@ import transformers
 import torch
 
 
-dataset = datasets.load_dataset("syntaxgym.py", "mvrr_mod")
-metric = datasets.load_metric("syntaxgym.py", "mvrr_mod")
+dataset = datasets.load_dataset("syntaxgym.py", "subordination_src-src")
+metric = datasets.load_metric("syntaxgym.py")
 
-# model_ref = "gpt2"
-model_ref = "hf-internal-testing/tiny-random-gpt_neo"
+model_ref = "gpt2"
+# model_ref = "hf-internal-testing/tiny-random-gpt_neo"
 
-tokenizer = transformers.AutoTokenizer.from_pretrained(model_ref)
-# DEV
-tokenizer.pad_token = tokenizer.eos_token
-
-model = transformers.AutoModelForCausalLM.from_pretrained(model_ref)
-model.eval()
-
-
-# all_sentences: List[List[str]] = [item["conditions"]["content"] for item in dataset["test"]]
-# all_sentences_flat = list(itertools.chain.from_iterable(all_sentences))
-
-tokenized = tokenizer(all_sentences_flat,
-                      return_tensors="pt", padding=True, return_offsets_mapping=True)
-for item in dataset["test"]:
-    # TODO full preprocessing setup
-    condition_names = item["conditions"]["condition_name"]
-    tokenized = tokenizer(item["conditions"]["content"], return_tensors="pt",
-                          padding=True, return_offsets_mapping=True)
-
-    print(item)
-    print(tokenized)
-    print(tokenized["offset_mapping"].shape)
-
-    with torch.no_grad():
-        # Pre-softmax predictive distribution (shape B * T * V)
-        output = model(tokenized["input_ids"])[0]
-    surprisals = -output.log_softmax(dim=2) / np.log(2)
-
-    result = metric.compute(surprisals=surprisals,
-                            item_number=item["item_number"],
-                            condition_names=condition_names,
-                            input_ids=tokenized["input_ids"],
-                            offset_mapping=tokenized["offset_mapping"])
-
-    break
+result = metric.compute(suite=dataset["test"], model_id=model_ref)
+print(result)