Get token aggregation working; just need to support predictions

syntaxgym.py

@@ -5,13 +5,16 @@ SyntaxGym dataset as used in Hu et al. (2020).
 """
 
 
+from collections import defaultdict
 from copy import deepcopy
 import json
 from pathlib import Path
 import re
-from typing import List
+from typing import List, Tuple
 
 import datasets
+import numpy as np
+import torch
 
 from .prediction import Prediction
 
@@ -39,6 +42,15 @@ for suite_f in Path("test_suites").glob("*.json"):
 SUITE_JSONS = {suite["meta"]["name"]: suite for suite in SUITE_JSONS}
 
 
+def condition_to_string(cond):
+    ret = " ".join([region["content"].lstrip()
+                    for region in cond["regions"]
+                    if region["content"].strip() != ""])
+    ret = re.sub(r"\s+,", ",", ret)
+
+    return ret
+
+
 class SyntaxGymSuiteConfig(datasets.BuilderConfig):
 
     def __init__(self, suite_json, version=datasets.Version("1.0.0"), **kwargs):
@@ -68,7 +80,7 @@ class SyntaxGym(datasets.GeneratorBasedBuilder):
         }
 
         features = {
-            "item_number": datasets.Value("string"),
+            "item_number": datasets.Value("int32"),
             "conditions": datasets.Sequence(condition_spec)
         }
 
@@ -95,10 +107,7 @@ class SyntaxGym(datasets.GeneratorBasedBuilder):
         for item in suite_json["items"]:
             # Convert to sentence input.
             for cond in item["conditions"]:
-                cond["content"] = " ".join([region["content"].lstrip()
-                                            for region in cond["regions"]
-                                            if region["content"].strip() != ""])
-                cond["content"] = re.sub(r"\s+,", ",", cond["content"])
+                cond["content"] = condition_to_string(cond)
 
             yield item["item_number"], item
 
@@ -117,16 +126,18 @@ class SyntaxGymMetric(datasets.Metric):
         ]
 
     def _info(self):
+        seq = datasets.Sequence
         features = datasets.Features({
-            "conditions": datasets.Sequence({
-                "condition_name": datasets.Value("string"),
-                "regions": datasets.Sequence({
-                    "region_number": datasets.Value("int32"),
-                    "metric_value": {
-                        "sum": datasets.Value("float32")
-                    },
-                }),
-            })
+            # 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"))),
         })
         return datasets.MetricInfo(
             description="TODO",
@@ -135,5 +146,100 @@ class SyntaxGymMetric(datasets.Metric):
             features=features,
         )
 
-    def _compute(self, region_surprisals):
-        suite_with_results = deepcopy(self.suite)
+    def _compute(self, surprisals, item_number, condition_names,
+                 input_ids, offset_mapping):
+        # surprisals: B * T * V
+        surprisals = torch.tensor(surprisals)
+        assert surprisals.ndim == 3
+
+        # input_ids: B * T
+        input_ids = torch.tensor(input_ids)
+        assert input_ids.ndim == 2
+
+        # Get surprisals of expected words.
+        surps_shifted = surprisals[:, :-1, :]
+        expected_ids = input_ids[:, 1:]
+
+        # TODO: check this logic
+        tt = expected_ids.unsqueeze(2)
+        surprisals = torch.gather(surps_shifted, 2, expected_ids.unsqueeze(2)) \
+            .squeeze(2)
+        # This is the original, which works but not with multiple axes in expected_ids
+        # surprisals = surps_shifted[range(surps_shifted.shape[0]), expected_ids]
+
+        # surprisals is now B * (T - 1)
+
+        #### aggregate
+        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)
+
+        for i, (i_cond, i_inputs) in enumerate(zip(condition_names, input_ids)):
+            for region_number, region_tokens in region2tokens[i_cond].items():
+                for token in region_tokens:
+                    if token < surprisals.shape[1]:
+                        region_totals[i_cond][region_number] += surprisals[i, token]
+                    else:
+                        # TODO don't think this is an issue, just should clean
+                        # up the aggregation output
+                        print("Warning: exceeded ", token)
+
+        region_totals = {c: dict(totals) for c, totals in region_totals.items()}
+
+    def get_region_edges(self, item_number, condition_name):
+        """
+        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)
+
+        idx = 0
+        ret = []
+        for r_idx, region in enumerate(cond["regions"]):
+            ret.append(idx)
+
+            content = region["content"]
+            region_size = len(content)
+            if content.strip() != "" and r_idx != 0 and not content.startswith(","):
+                # Add joining space
+                region_size += 1
+
+            idx += region_size
+
+        return ret
+
+    def compute_region_token_mapping(self, item_number, condition_names, input_ids,
+                                     offset_mapping: List[Tuple[int, int]]):
+        # input_ids: B * T
+        # offset_mapping: B * T * 2
+
+        region2tokens = {cond: defaultdict(list) for cond in condition_names}
+
+        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)
+
+            t_cursor, r_cursor = 0, 0
+            while t_cursor < i_tokens.shape[0]:
+                # token = i_tokens[t_cursor]
+                token_char_start, token_char_end = i_offsets[t_cursor]
+
+                region_start = region_edges[r_cursor]
+                region_end = region_edges[r_cursor + 1] \
+                    if r_cursor + 1 < len(region_edges) else np.inf
+
+                # 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)
+                t_cursor += 1
+
+        return region2tokens

test.py

@@ -1,4 +1,5 @@
 import datasets
+import numpy as np
 import transformers
 import torch
 
@@ -6,25 +7,36 @@ import torch
 dataset = datasets.load_dataset("syntaxgym.py", "mvrr_mod")
 metric = datasets.load_metric("syntaxgym.py", "mvrr_mod")
 
-tokenizer = transformers.AutoTokenizer.from_pretrained("gpt2")
+# 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("gpt2")
+model = transformers.AutoModelForCausalLM.from_pretrained(model_ref)
 model.eval()
 
 
 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)
+                          padding=True, return_offsets_mapping=True)
 
     print(item)
     print(tokenized)
+    print(tokenized["offset_mapping"].shape)
 
     with torch.no_grad():
-        print(model(tokenized["input_ids"]))
-
-    # TODO eval
+        # 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