Add science_ie default config that only converts the original structure to a dictionary format

README.md

@@ -51,7 +51,7 @@ dataset_info:
   - name: test
     num_bytes: 399069
     num_examples: 838
-  download_size: 391944
+  download_size: 13704567
   dataset_size: 1788822
 - config_name: re
   features:
@@ -80,8 +80,8 @@ dataset_info:
           '2': Hyponym-of
   splits:
   - name: train
-    num_bytes: 11738520
-    num_examples: 24558
+    num_bytes: 11737101
+    num_examples: 24556
   - name: validation
     num_bytes: 2347796
     num_examples: 4838
@@ -89,7 +89,57 @@ dataset_info:
     num_bytes: 2835275
     num_examples: 6618
   download_size: 13704567
-  dataset_size: 16921591
+  dataset_size: 16920172
+- config_name: science_ie
+  features:
+  - name: id
+    dtype: string
+  - name: text
+    dtype: string
+  - name: keyphrases
+    list:
+    - name: id
+      dtype: string
+    - name: start
+      dtype: int32
+    - name: end
+      dtype: int32
+    - name: type
+      dtype:
+        class_label:
+          names:
+            '0': Material
+            '1': Process
+            '2': Task
+    - name: type_
+      dtype: string
+  - name: relations
+    list:
+    - name: arg1
+      dtype: string
+    - name: arg2
+      dtype: string
+    - name: relation
+      dtype:
+        class_label:
+          names:
+            '0': O
+            '1': Synonym-of
+            '2': Hyponym-of
+    - name: relation_
+      dtype: string
+  splits:
+  - name: train
+    num_bytes: 640060
+    num_examples: 350
+  - name: validation
+    num_bytes: 112588
+    num_examples: 50
+  - name: test
+    num_bytes: 206857
+    num_examples: 100
+  download_size: 13704567
+  dataset_size: 959505
 - config_name: subtask_a
   features:
   - name: id
@@ -105,7 +155,7 @@ dataset_info:
           '2': I
   splits:
   - name: train
-    num_bytes: 1185670
+    num_bytes: 1185658
     num_examples: 2388
   - name: validation
     num_bytes: 204095
@@ -114,7 +164,7 @@ dataset_info:
     num_bytes: 399069
     num_examples: 838
   download_size: 13704567
-  dataset_size: 1788834
+  dataset_size: 1788822
 - config_name: subtask_b
   features:
   - name: id
@@ -131,7 +181,7 @@ dataset_info:
           '3': T
   splits:
   - name: train
-    num_bytes: 1185670
+    num_bytes: 1185658
     num_examples: 2388
   - name: validation
     num_bytes: 204095
@@ -140,7 +190,7 @@ dataset_info:
     num_bytes: 399069
     num_examples: 838
   download_size: 13704567
-  dataset_size: 1788834
+  dataset_size: 1788822
 - config_name: subtask_c
   features:
   - name: id
@@ -157,7 +207,7 @@ dataset_info:
             '2': H
   splits:
   - name: train
-    num_bytes: 20103682
+    num_bytes: 20102706
     num_examples: 2388
   - name: validation
     num_bytes: 3575511
@@ -166,17 +216,7 @@ dataset_info:
     num_bytes: 6431513
     num_examples: 838
   download_size: 13704567
-  dataset_size: 30110706
-configs:
-- config_name: ner
-  data_files:
-  - split: train
-    path: ner/train-*
-  - split: validation
-    path: ner/validation-*
-  - split: test
-    path: ner/test-*
-  default: true
+  dataset_size: 30109730
 ---
 
 # Dataset Card for ScienceIE
@@ -212,8 +252,6 @@ configs:
 - **Repository:** [https://github.com/ScienceIE/scienceie.github.io](https://github.com/ScienceIE/scienceie.github.io)
 - **Paper:** [SemEval 2017 Task 10: ScienceIE - Extracting Keyphrases and Relations from Scientific Publications](https://arxiv.org/abs/1704.02853)
 - **Leaderboard:** [https://competitions.codalab.org/competitions/15898](https://competitions.codalab.org/competitions/15898)
-- **Size of downloaded dataset files:** 13.7 MB
-- **Size of generated dataset files:** 17.4 MB
 
 ### Dataset Summary
 
@@ -236,7 +274,8 @@ There are three subtasks:
     - HYPONYM-OF: The relationship between two keyphrases A and B is HYPONYM-OF if semantic field of A is included within that of B. One example is Red HYPONYM-OF Color. 
     - SYNONYM-OF: The relationship between two keyphrases A and B is SYNONYM-OF if they both denote the same semantic field, for example Machine Learning SYNONYM-OF ML.
 
-Note: In this repository the documents were split into sentences using spaCy, resulting in a 2388, 400, 838 split. The `id` consists of the document id and the example index within the document separated by an underscore, e.g. `S0375960115004120_1`. This should enable you to reconstruct the documents from the sentences.
+Note: The default config `science_ie` converts the original .txt & .ann files to a dictionary format that is easier to use. 
+For every other configuration the documents were split into sentences using spaCy, resulting in a 2388, 400, 838 split. The `id` consists of the document id and the example index within the document separated by an underscore, e.g. `S0375960115004120_1`. This should enable you to reconstruct the documents from the sentences.
 
 ### Supported Tasks and Leaderboards
 
@@ -251,11 +290,31 @@ The language in the dataset is English.
 
 ### Data Instances
 
+#### science_ie
+An example of "train" looks as follows:
+```json
+{
+  "id": "S221266781300018X", 
+  "text": "Amodel are proposed for modeling data-centric Web services which are powered by relational databases and interact with users according to logical formulas specifying input constraints, control-flow constraints and state/output/action rules. The Linear Temporal First-Order Logic (LTL-FO) formulas over inputs, states, outputs and actions are used to express the properties to be verified.We have proven that automatic verification of LTL-FO properties of data-centric Web services under input-bounded constraints is decidable by reducing Web services to data-centric Web applications. Thus, we can verify Web service specifications using existing verifier designed for Web applications.", 
+  "keyphrases": [
+    {
+      "id": "T1", "start": 24, "end": 58, "type": 2, "type_": "Task"
+    }, 
+    ..., 
+    {"id": "T3", "start": 245, "end": 278, "type": 1, "type_": "Process"}, 
+    {"id": "T4", "start": 280, "end": 286, "type": 1, "type_": "Process"}, 
+    ...
+  ], 
+  "relations": [
+    {"arg1": "T4", "arg2": "T3", "relation": 1, "relation_": "Synonym-of"}, 
+    {"arg1": "T3", "arg2": "T4", "relation": 1, "relation_": "Synonym-of"}
+  ]
+}
+```
+
+
 #### subtask_a
-- **Size of downloaded dataset files:** 13.7 MB
-- **Size of the generated dataset:** 17.4 MB
-  
-An example of 'train' looks as follows:
+An example of "train" looks as follows:
 ```json
 {
   "id": "S0375960115004120_1", 
@@ -264,10 +323,7 @@ An example of 'train' looks as follows:
 }
 ```
 #### subtask_b
-- **Size of downloaded dataset files:** 13.7 MB
-- **Size of the generated dataset:** 17.4 MB
-  
-An example of 'train' looks as follows:
+An example of "train" looks as follows:
 ```json
 {
   "id": "S0375960115004120_2", 
@@ -277,10 +333,7 @@ An example of 'train' looks as follows:
 ```
 
 #### subtask_c
-- **Size of downloaded dataset files:** 13.7 MB
-- **Size of the generated dataset:** 30.1 MB
-  
-An example of 'train' looks as follows:
+An example of "train" looks as follows:
 ```json
 {
   "id": "S0375960115004120_3",
@@ -292,10 +345,7 @@ Note: The tag sequence consists of vectors for each token, that encode what the
 and every other token in the sequence is for the first token in each key phrase.
 
 #### ner
-- **Size of downloaded dataset files:** 13.7 MB
-- **Size of the generated dataset:** 17.4 MB
-  
-An example of 'train' looks as follows:
+An example of "train" looks as follows:
 ```json
 {
   "id": "S0375960115004120_4", 
@@ -305,10 +355,7 @@ An example of 'train' looks as follows:
 ```
 
 #### re
-- **Size of downloaded dataset files:** 13.7 MB
-- **Size of the generated dataset:** 16.4 MB
-  
-An example of 'train' looks as follows:
+An example of "train" looks as follows:
 ```json
 {
   "id": "S0375960115004120_5", 
@@ -325,12 +372,36 @@ An example of 'train' looks as follows:
 
 ### Data Fields
 
+#### science_ie
+- `id`: the instance id of this document, a `string` feature.
+- `text`: the text of this document, a `string` feature.
+- `keyphrases`: the list of keyphrases of this document, a `list` of `dict`.
+  - `id`: the instance id of this keyphrase, a `string` feature.
+  - `start`: the character offset start of this keyphrase, an `int` feature.
+  - `end`: the character offset end of this keyphrase, exclusive, an `int` feature.
+  - `type`: the key phrase type of this keyphrase, a classification label.
+  - `type_`: the key phrase type of this keyphrase, a `string` feature.
+- `relations`: the list of relations of this document, a `list` of `dict`.
+  - `arg1`: the instance id of the first keyphrase, a `string` feature.
+  - `arg2`: the instance id of the second keyphrase, a `string` feature.
+  - `relation`: the relation label of this instance, a classification label.
+  - `relation_`: the relation label of this instance, a `string` feature.
+
+Keyphrase types:
+```json
+{"O": 0, "Material": 1, "Process": 2, "Task": 3}
+```
+Relation types:
+```json
+{"O": 0, "Synonym-of": 1, "Hyponym-of": 2}
+```
+
 #### subtask_a
 - `id`: the instance id of this sentence, a `string` feature.
 - `tokens`: the list of tokens of this sentence, obtained with spaCy, a `list` of `string` features.
 - `tags`: the list of tags of this sentence marking a token as being outside, at the beginning, or inside a key phrase, a `list` of classification labels.
 
-```python
+```json
 {"O": 0, "B": 1, "I": 2}
 ```
 
@@ -339,7 +410,7 @@ An example of 'train' looks as follows:
 - `tokens`: the list of tokens of this sentence, obtained with spaCy, a `list` of `string` features.
 - `tags`: the list of tags of this sentence marking a token as being outside a key phrase, or being part of a material, process or task, a `list` of classification labels.
 
-```python
+```json
 {"O": 0, "M": 1, "P": 2, "T": 3}
 ```
 
@@ -348,7 +419,7 @@ An example of 'train' looks as follows:
 - `tokens`: the list of tokens of this sentence, obtained with spaCy, a `list` of `string` features.
 - `tags`: a vector for each token, that encodes what the relationship between that token and every other token in the sequence is for the first token in each key phrase, a `list` of a `list` of a classification label.
 
-```python
+```json
 {"O": 0, "S": 1, "H": 2}
 ```
 
@@ -357,7 +428,7 @@ An example of 'train' looks as follows:
 - `tokens`: the list of tokens of this sentence, obtained with spaCy, a `list` of `string` features.
 - `tags`: the list of ner tags of this sentence, a `list` of classification labels.
 
-```python
+```json
 {"O": 0, "B-Material": 1, "I-Material": 2, "B-Process": 3, "I-Process": 4, "B-Task": 5, "I-Task": 6}
 ```
 
@@ -372,19 +443,20 @@ An example of 'train' looks as follows:
 - `arg2_type`: the key phrase type of the relation arg2 mention, a `string` feature.
 - `relation`: the relation label of this instance, a classification label.
 
-```python
+```json
 {"O": 0, "Synonym-of": 1, "Hyponym-of": 2}
 ```
 
 ### Data Splits
 
-|           | Train | Dev  | Test |
-|-----------|-------|------|------|
-| subtask_a | 2388  | 400  | 838  |
-| subtask_b | 2388  | 400  | 838  |
-| subtask_c | 2388  | 400  | 838  |
-| ner       | 2388  | 400  | 838  |
-| re        | 24558 | 4838 | 6618 |
+|            | Train | Dev  | Test |
+|------------|-------|------|------|
+| science_ie | 350   | 50   | 100  |
+| subtask_a  | 2388  | 400  | 838  |
+| subtask_b  | 2388  | 400  | 838  |
+| subtask_c  | 2388  | 400  | 838  |
+| ner        | 2388  | 400  | 838  |
+| re         | 24558 | 4838 | 6618 |
 
 ## Dataset Creation
 

science_ie.py

@@ -13,13 +13,11 @@
 # limitations under the License.
 """ScienceIE is a dataset for the SemEval task of extracting key phrases and relations between them from scientific documents"""
 
-
 import glob
 import datasets
 
 from pathlib import Path
 from itertools import permutations
-from spacy.lang.en import English
 
 # Find for instance the citation on arxiv or on the dataset repo/website
 _CITATION = """\
@@ -92,9 +90,10 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
     """ScienceIE is a dataset for the task of extracting key phrases and relations between them from scientific
     documents"""
 
-    VERSION = datasets.Version("1.0.0")
+    VERSION = datasets.Version("1.1.0")
 
     BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="science_ie", version=VERSION, description="Full ScienceIE dataset"),
         datasets.BuilderConfig(name="subtask_a", version=VERSION,
                                description="Subtask A of ScienceIE for tokens being outside, at the beginning, "
                                            "or inside a key phrase"),
@@ -107,10 +106,40 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
         datasets.BuilderConfig(name="re", version=VERSION, description="Relation extraction part of ScienceIE"),
     ]
 
-    DEFAULT_CONFIG_NAME = "ner"
+    DEFAULT_CONFIG_NAME = "science_ie"
 
     def _info(self):
-        if self.config.name == "subtask_a":
+        if self.config.name == "science_ie":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "text": datasets.Value("string"),
+                    "keyphrases": [
+                        {
+                            "id": datasets.Value("string"),
+                            "start": datasets.Value("int32"),
+                            "end": datasets.Value("int32"),
+                            "type": datasets.features.ClassLabel(
+                                names=[
+                                    "Material",
+                                    "Process",
+                                    "Task"
+                                ]
+                            ),
+                            "type_": datasets.Value("string")
+                        }
+                    ],
+                    "relations": [
+                        {
+                            "arg1": datasets.Value("string"),
+                            "arg2": datasets.Value("string"),
+                            "relation": datasets.features.ClassLabel(names=["O", "Synonym-of", "Hyponym-of"]),
+                            "relation_": datasets.Value("string")
+                        }
+                    ]
+                }
+            )
+        elif self.config.name == "subtask_a":
             features = datasets.Features(
                 {
                     "id": datasets.Value("string"),
@@ -199,8 +228,12 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
     def _generate_examples(self, dir_path):
         # The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
         annotation_files = glob.glob(dir_path + "/**/*.ann", recursive=True)
-        word_splitter = English()
-        word_splitter.add_pipe('sentencizer')
+        if self.config.name != "science_ie":
+            from spacy.lang.en import English
+            word_splitter = English()
+            word_splitter.add_pipe('sentencizer')
+        else:
+            word_splitter = None
         for f_anno_file in annotation_files:
             doc_example_idx = 0
             f_anno_path = Path(f_anno_file)
@@ -209,7 +242,10 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
             with open(f_anno_path, mode="r", encoding="utf8") as f_anno, \
                     open(f_text_path, mode="r", encoding="utf8") as f_text:
                 text = f_text.read().strip()
-                doc = word_splitter(text)
+                if word_splitter:
+                    doc = word_splitter(text)
+                else:
+                    doc = None
                 entities = []
                 synonym_groups = []
                 hyponyms = []
@@ -242,120 +278,149 @@ class ScienceIE(datasets.GeneratorBasedBuilder):
                                 print("Spans don't match for anno " + line.strip() + " in file " + f_anno_file)
                             char_start = int(start)
                             char_end = int(end)
-                            entity_span = doc.char_span(char_start, char_end, alignment_mode="expand")
-                            start = entity_span.start
-                            end = entity_span.end
-                            entities.append({
-                                "id": identifier,
-                                "start": start,
-                                "end": end,
-                                "char_start": char_start,
-                                "char_end": char_end,
-                                "type": key_type
-                            })
-                # check if any annotation is lost during sentence splitting
-                synonym_groups_used = [False for _ in synonym_groups]
-                hyponyms_used = [False for _ in hyponyms]
-                for sent in doc.sents:
-                    token_offset = sent.start
-                    tokens = [token.text for token in sent]
-                    tags = ["O" for _ in tokens]
-                    sent_entities = []
-                    sent_entity_ids = []
-                    for entity in entities:
-                        if entity["start"] >= sent.start and entity["end"] <= sent.end:
-                            sent_entity = {k: v for k, v in entity.items()}
-                            sent_entity["start"] -= token_offset
-                            sent_entity["end"] -= token_offset
-                            sent_entities.append(sent_entity)
-                            sent_entity_ids.append(entity["id"])
-                    for entity in sent_entities:
-                        tags[entity["start"]] = "B-" + entity["type"]
-                        for i in range(entity["start"] + 1, entity["end"]):
-                            tags[i] = "I-" + entity["type"]
-
-                    relations = []
-                    entity_pairs_in_relation = []
+                            if doc:
+                                entity_span = doc.char_span(char_start, char_end, alignment_mode="expand")
+                                start = entity_span.start
+                                end = entity_span.end
+                                entities.append({
+                                    "id": identifier,
+                                    "start": start,
+                                    "end": end,
+                                    "char_start": char_start,
+                                    "char_end": char_end,
+                                    "type": key_type,
+                                    "type_": key_type
+                                })
+                            else:
+                                entities.append({
+                                    "id": identifier,
+                                    "start": char_start,
+                                    "end": char_end,
+                                    "type": key_type,
+                                    "type_": key_type
+                                })
+                if self.config.name == "science_ie":
+                    # just to pass the assertion at the end of the method, check is not relevant for this config
+                    synonym_groups_used = [True for _ in synonym_groups]
+                    hyponyms_used = [True for _ in hyponyms]
+                    gen_relations = []
                     for idx, synonym_group in enumerate(synonym_groups):
-                        if all(entity_id in sent_entity_ids for entity_id in synonym_group):
-                            synonym_groups_used[idx] = True
-                            for arg1_id, arg2_id in permutations(synonym_group, 2):
+                        for arg1_id, arg2_id in permutations(synonym_group, 2):
+                            gen_relations.append(dict(arg1=arg1_id, arg2=arg2_id, relation="Synonym-of",
+                                                      relation_="Synonym-of"))
+                    for hyponym in hyponyms:
+                        gen_relations.append(dict(arg1=hyponym["arg1_id"], arg2=hyponym["arg2_id"],
+                                                  relation="Hyponym-of", relation_="Hyponym-of"))
+                    yield doc_id, {
+                        "id": doc_id,
+                        "text": text,
+                        "keyphrases": entities,
+                        "relations": gen_relations
+                    }
+                else:
+                    # check if any annotation is lost during sentence splitting
+                    synonym_groups_used = [False for _ in synonym_groups]
+                    hyponyms_used = [False for _ in hyponyms]
+                    for sent in doc.sents:
+                        token_offset = sent.start
+                        tokens = [token.text for token in sent]
+                        tags = ["O" for _ in tokens]
+                        sent_entities = []
+                        sent_entity_ids = []
+                        for entity in entities:
+                            if entity["start"] >= sent.start and entity["end"] <= sent.end:
+                                sent_entity = {k: v for k, v in entity.items()}
+                                sent_entity["start"] -= token_offset
+                                sent_entity["end"] -= token_offset
+                                sent_entities.append(sent_entity)
+                                sent_entity_ids.append(entity["id"])
+                        for entity in sent_entities:
+                            tags[entity["start"]] = "B-" + entity["type"]
+                            for i in range(entity["start"] + 1, entity["end"]):
+                                tags[i] = "I-" + entity["type"]
+
+                        relations = []
+                        entity_pairs_in_relation = []
+                        for idx, synonym_group in enumerate(synonym_groups):
+                            if all(entity_id in sent_entity_ids for entity_id in synonym_group):
+                                synonym_groups_used[idx] = True
+                                for arg1_id, arg2_id in permutations(synonym_group, 2):
+                                    relations.append(
+                                        generate_relation(sent_entities, arg1_id, arg2_id, relation="Synonym-of"))
+                                    entity_pairs_in_relation.append((arg1_id, arg2_id))
+                        for idx, hyponym in enumerate(hyponyms):
+                            if hyponym["arg1_id"] in sent_entity_ids and hyponym["arg2_id"] in sent_entity_ids:
+                                hyponyms_used[idx] = True
                                 relations.append(
-                                    generate_relation(sent_entities, arg1_id, arg2_id, relation="Synonym-of"))
-                                entity_pairs_in_relation.append((arg1_id, arg2_id))
-                    for idx, hyponym in enumerate(hyponyms):
-                        if hyponym["arg1_id"] in sent_entity_ids and hyponym["arg2_id"] in sent_entity_ids:
-                            hyponyms_used[idx] = True
-                            relations.append(
-                                generate_relation(sent_entities, hyponym["arg1_id"], hyponym["arg2_id"],
-                                                  relation="Hyponym-of"))
+                                    generate_relation(sent_entities, hyponym["arg1_id"], hyponym["arg2_id"],
+                                                      relation="Hyponym-of"))
 
-                            entity_pairs_in_relation.append((arg1_id, arg2_id))
-                    entity_pairs = [(arg1["id"], arg2["id"]) for arg1, arg2 in permutations(sent_entities, 2)
-                                    if (arg1["id"], arg2["id"]) not in entity_pairs_in_relation]
-                    for arg1_id, arg2_id in entity_pairs:
-                        relations.append(generate_relation(sent_entities, arg1_id, arg2_id, relation="O"))
+                                entity_pairs_in_relation.append((arg1_id, arg2_id))
+                        entity_pairs = [(arg1["id"], arg2["id"]) for arg1, arg2 in permutations(sent_entities, 2)
+                                        if (arg1["id"], arg2["id"]) not in entity_pairs_in_relation]
+                        for arg1_id, arg2_id in entity_pairs:
+                            relations.append(generate_relation(sent_entities, arg1_id, arg2_id, relation="O"))
 
-                    if self.config.name == "subtask_a":
-                        doc_example_idx += 1
-                        key = f"{doc_id}_{doc_example_idx}"
-                        # Yields examples as (key, example) tuples
-                        yield key, {
-                            "id": key,
-                            "tokens": tokens,
-                            "tags": [tag[0] for tag in tags]
-                        }
-                    elif self.config.name == "subtask_b":
-                        doc_example_idx += 1
-                        key = f"{doc_id}_{doc_example_idx}"
-                        # Yields examples as (key, example) tuples
-                        key_phrase_tags = []
-                        for tag in tags:
-                            if tag == "O":
-                                key_phrase_tags.append(tag)
-                            else:
-                                # use first letter of key phrase type
-                                key_phrase_tags.append(tag[2])
-                        yield key, {
-                            "id": key,
-                            "tokens": tokens,
-                            "tags": key_phrase_tags
-                        }
-                    elif self.config.name == "subtask_c":
-                        doc_example_idx += 1
-                        key = f"{doc_id}_{doc_example_idx}"
-                        tag_vectors = [["O" for _ in tokens] for _ in tokens]
-                        for relation in relations:
-                            tag = relation["relation"][0]
-                            if tag != "O":
-                                tag_vectors[relation["arg1_start"]][relation["arg2_start"]] = tag
-                        # Yields examples as (key, example) tuples
-                        yield key, {
-                            "id": key,
-                            "tokens": tokens,
-                            "tags": tag_vectors
-                        }
-                    elif self.config.name == "re":
-                        for relation in relations:
+                        if self.config.name == "subtask_a":
                             doc_example_idx += 1
                             key = f"{doc_id}_{doc_example_idx}"
                             # Yields examples as (key, example) tuples
-                            example = {
+                            yield key, {
                                 "id": key,
-                                "tokens": tokens
+                                "tokens": tokens,
+                                "tags": [tag[0] for tag in tags]
+                            }
+                        elif self.config.name == "subtask_b":
+                            doc_example_idx += 1
+                            key = f"{doc_id}_{doc_example_idx}"
+                            # Yields examples as (key, example) tuples
+                            key_phrase_tags = []
+                            for tag in tags:
+                                if tag == "O":
+                                    key_phrase_tags.append(tag)
+                                else:
+                                    # use first letter of key phrase type
+                                    key_phrase_tags.append(tag[2])
+                            yield key, {
+                                "id": key,
+                                "tokens": tokens,
+                                "tags": key_phrase_tags
+                            }
+                        elif self.config.name == "subtask_c":
+                            doc_example_idx += 1
+                            key = f"{doc_id}_{doc_example_idx}"
+                            tag_vectors = [["O" for _ in tokens] for _ in tokens]
+                            for relation in relations:
+                                tag = relation["relation"][0]
+                                if tag != "O":
+                                    tag_vectors[relation["arg1_start"]][relation["arg2_start"]] = tag
+                            # Yields examples as (key, example) tuples
+                            yield key, {
+                                "id": key,
+                                "tokens": tokens,
+                                "tags": tag_vectors
+                            }
+                        elif self.config.name == "re":
+                            for relation in relations:
+                                doc_example_idx += 1
+                                key = f"{doc_id}_{doc_example_idx}"
+                                # Yields examples as (key, example) tuples
+                                example = {
+                                    "id": key,
+                                    "tokens": tokens
+                                }
+                                for k, v in relation.items():
+                                    example[k] = v
+                                yield key, example
+                        else:  # NER config
+                            doc_example_idx += 1
+                            key = f"{doc_id}_{doc_example_idx}"
+                            # Yields examples as (key, example) tuples
+                            yield key, {
+                                "id": key,
+                                "tokens": tokens,
+                                "tags": tags
                             }
-                            for k, v in relation.items():
-                                example[k] = v
-                            yield key, example
-                    else:  # NER config
-                        doc_example_idx += 1
-                        key = f"{doc_id}_{doc_example_idx}"
-                        # Yields examples as (key, example) tuples
-                        yield key, {
-                            "id": key,
-                            "tokens": tokens,
-                            "tags": tags
-                        }
 
         assert all(synonym_groups_used) and all(hyponyms_used), \
             f"Annotations were lost: {len([e for e in synonym_groups_used if e])} synonym annotations," \