from https://github.com/ArneBinder/pie-datasets/pull/103

README.md

@@ -22,13 +22,18 @@ The language in the dataset is English (scientific academic publications on comp
 
 ### Dataset Variants
 
-The `sciarg` dataset comes in a single version (`default`) with `BratDocumentWithMergedSpans` as document type. Note,
-that this in contrast to the base `brat` dataset, where the document type for the `default` variant is `BratDocument`.
-The reason is that the SciArg dataset was published with spans that are just fragmented by whitespace which seems
+The `sciarg` dataset comes in two versions: `default` and `resolve_parts_of_same`.
+
+First, the `default` version with `BratDocumentWithMergedSpans` as document type.
+In contrast to the base `brat` dataset, where the document type for the `default` variant is `BratDocument`,
+the SciArg dataset was published with spans that are just fragmented by whitespace which seems
 to be because of the annotation tool used. In the `sciarg` dataset, we merge these fragments, so that the document type
-can be `BratDocumentWithMergedSpans` (this is easier to handle for most of the task modules). However, fragmented
-spans are conceptually also available in SciArg, but they are marked with the `parts_of_same` relation which are kept
-as they are in the `sciarg` (`default`) dataset.
+can be `BratDocumentWithMergedSpans` (this is easier to handle for most of the task modules).
+Fragmented spans, which belong to the same argumentative unit, are marked with `parts_of_same` relations.
+
+Second, the `resolve_parts_of_same` version with `BratDocument` as document type.
+In this version, all fragmented spans which were separated by other argumentative or non-argumentative spans and
+are connected via the `parts_of_same` relations are converted to `LabeledMultiSpans`.
 
 ### Data Schema
 
@@ -42,41 +47,28 @@ from pie_datasets import load_dataset, builders
 # load default version
 datasets = load_dataset("pie/sciarg")
 doc = datasets["train"][0]
-assert isinstance(doc, builders.brat.BratDocument)
+assert isinstance(doc, builders.brat.BratDocumentWithMergedSpans)
 
-# load version with merged span fragments
-dataset_merged_spans = load_dataset("pie/sciarg", name="merge_fragmented_spans")
-doc_merged_spans = dataset_merged_spans["train"][0]
-assert isinstance(doc_merged_spans, builders.brat.BratDocumentWithMergedSpans)
+# load version with resolved parts_of_same relations
+datasets = load_dataset("pie/sciarg", name='resolve_parts_of_same')
+doc = datasets["train"][0]
+assert isinstance(doc, builders.brat.BratDocument)
 ```
 
-### Document Converters
-
-The dataset provides document converters for the following target document types:
-
-- `pytorch_ie.documents.TextDocumentWithLabeledSpansAndBinaryRelations`
-  - `LabeledSpans`, converted from `BratDocument`'s `spans`
-    - labels: `background_claim`, `own_claim`, `data`
-    - if `spans` contain whitespace at the beginning and/or the end, the whitespace are trimmed out.
-  - `BinraryRelations`, converted from `BratDocument`'s `relations`
-    - labels: `supports`, `contradicts`, `semantically_same`, `parts_of_same`
-    - if the `relations` label is `semantically_same` or `parts_of_same`, they are merged if they are the same arguments after sorting.
-- `pytorch_ie.documents.TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions`
-  - `LabeledSpans`, as above
-  - `BinaryRelations`, as above
-  - `LabeledPartitions`, partitioned `BratDocument`'s `text`, according to the paragraph, using regex.
-    - labels: `title`, `abstract`, `H1`
-
-See [here](https://github.com/ChristophAlt/pytorch-ie/blob/main/src/pytorch_ie/documents.py) for the document type
-definitions.
-
 ### Data Splits
 
 The dataset consists of a single `train` split that has 40 documents.
 
 For detailed statistics on the corpus, see Lauscher et al. ([2018](<(https://aclanthology.org/W18-5206/)>), p. 43), and the author's [resource analysis](https://github.com/anlausch/sciarg_resource_analysis).
 
-### Label Descriptions
+### Label Descriptions and Statistics
+
+In this section, we report our own corpus' statistics; however, there are currently discrepancies in label counts between our report and:
+
+- previous report in [Lauscher et al., 2018](https://aclanthology.org/W18-5206/), p. 43),
+- current report above here (labels counted in `BratDocumentWithMergedSpans`'s);
+
+possibly since [Lauscher et al., 2018](https://aclanthology.org/W18-5206/) presents the numbers of the real argumentative components, whereas here discontinuous components are still split (marked with the `parts_of_same` helper relation) and, thus, count per fragment.
 
 #### Components
 
@@ -113,18 +105,57 @@ For detailed statistics on the corpus, see Lauscher et al. ([2018](<(https://acl
 
 - `semantically_same`: between two mentions of effectively the same claim or data component. Can be seen as *argument coreference*, analogous to entity, and *event coreference*. This relation is considered symmetric (i.e., **bidirectional**) and non-argumentative.
   (Lauscher et al. 2018, p.41; following [Dung, 1995](https://www.sciencedirect.com/science/article/pii/000437029400041X?via%3Dihub))
-- `parts_of_same`: when a single component is split up in several parts. It is **non-argumentative**, **bidirectional**, but also **intra-component**
+- `parts_of_same` (only in the `default` dataset variant): when a single component is split up in several parts. It is **non-argumentative**, **bidirectional**, but also **intra-component**
 
 (*Annotation Guidelines*, pp. 4-6)
 
-**Important note on label counts**:
+#### Examples
 
-There are currently discrepancies in label counts between
+![sample1](img/leaannof3.png)
 
-- previous report in [Lauscher et al., 2018](https://aclanthology.org/W18-5206/), p. 43),
-- current report above here (labels counted in `BratDocument`'s);
+Above: Diagram from *Annotation Guildelines* (p.6)
 
-possibly since [Lauscher et al., 2018](https://aclanthology.org/W18-5206/) presents the numbers of the real argumentative components, whereas here discontinuous components are still split (marked with the `parts_of_same` helper relation) and, thus, count per fragment.
+Below: Subset of relations in `A01`
+
+![sample2](img/sciarg-sam.png)
+
+### Document Converters
+
+The dataset provides document converters for the following target document types:
+
+From `default` version:
+
+- `pie_modules.documents.TextDocumentWithLabeledSpansAndBinaryRelations`
+  - `labeled_spans`: `LabeledSpan` annotations, converted from `BratDocumentWithMergedSpans`'s `spans`
+    - labels: `background_claim`, `own_claim`, `data`
+    - if `spans` contain whitespace at the beginning and/or the end, that whitespace is trimmed out.
+  - `binary_relations`: `BinaryRelation` annotations, converted from `BratDocumentWithMergedSpans`'s `relations`
+    - labels: `supports`, `contradicts`, `semantically_same`, `parts_of_same`
+    - if the `relations` label is `semantically_same` or `parts_of_same` (i.e. it is a symmetric relation), their arguments are sorted by their start and end indices.
+- `pie_modules.documents.TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions`
+  - `labeled_spans`, as above
+  - `binary_relations`, as above
+  - `labeled_partitions`, `LabeledSpan` annotations, created from splitting `BratDocumentWithMergedSpans`'s `text` at new paragraph in `xml` format.
+    - labels: `title`, `abstract`, `H1`
+
+From `resolve_parts_of_same` version:
+
+- `pie_modules.documents.TextDocumentWithLabeledMultiSpansAndBinaryRelations`:
+  - `labeled_multi_spans`: `LabeledMultiSpan` annotations, converted from `BratDocument`'s `spans`
+    - labels: as above
+    - if spans contain whitespace at the beginning and/or the end, that whitespace is trimmed out.
+  - `binary_relations`: `BinaryRelation` annotations, converted from `BratDocument`'s `relations`
+    - labels: `supports`, `contradicts`, `semantically_same`
+    - in contrast to the `default` version, spans connected with `parts_of_same` relation are stored as one labeled multi-span
+    - if the `relations` label is `semantically_same` (i.e. it is a symmetric relation), their arguments are sorted by their start and end indices.
+- `pie_modules.documents.TextDocumentWithLabeledMultiSpansBinaryRelationsAndLabeledPartitions`:
+  - `labeled_multi_spans`, as above
+  - `binary_relations`, as above
+  - `labeled_partitions`, `LabeledSpan` annotations, created from splitting `BratDocument`'s `text` at new paragraph in `xml` format.
+    - labels: `title`, `abstract`, `H1`
+
+See [here](https://github.com/ArneBinder/pie-modules/blob/main/src/pie_modules/documents.py) for the document type
+definitions.
 
 ## Dataset Creation
 

requirements.txt

@@ -1,2 +1,3 @@
 pie-datasets>=0.6.0,<0.9.0
-pie-modules>=0.8.0,<0.9.0
+pie-modules>=0.10.8,<0.11.0
+networkx>=3.0.0,<4.0.0

sciarg.py

@@ -1,23 +1,27 @@
 from pie_modules.document.processing import (
     RegexPartitioner,
     RelationArgumentSorter,
+    SpansViaRelationMerger,
     TextSpanTrimmer,
 )
-from pytorch_ie.core import Document
-from pytorch_ie.documents import (
+from pie_modules.documents import (
+    TextDocumentWithLabeledMultiSpansAndBinaryRelations,
+    TextDocumentWithLabeledMultiSpansBinaryRelationsAndLabeledPartitions,
     TextDocumentWithLabeledSpansAndBinaryRelations,
     TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions,
 )
+from pytorch_ie.core import Document
 
 from pie_datasets.builders import BratBuilder, BratConfig
-from pie_datasets.builders.brat import BratDocumentWithMergedSpans
+from pie_datasets.builders.brat import BratDocument, BratDocumentWithMergedSpans
+from pie_datasets.core.dataset import DocumentConvertersType
 from pie_datasets.document.processing import Caster, Pipeline
 
 URL = "http://data.dws.informatik.uni-mannheim.de/sci-arg/compiled_corpus.zip"
 SPLIT_PATHS = {"train": "compiled_corpus"}
 
 
-def get_common_pipeline_steps(target_document_type: type[Document]) -> dict:
+def get_common_converter_pipeline_steps(target_document_type: type[Document]) -> dict:
     return dict(
         cast=Caster(
             document_type=target_document_type,
@@ -31,6 +35,33 @@ def get_common_pipeline_steps(target_document_type: type[Document]) -> dict:
     )
 
 
+def get_common_converter_pipeline_steps_with_resolve_parts_of_same(
+    target_document_type: type[Document],
+) -> dict:
+    return dict(
+        cast=Caster(
+            document_type=target_document_type,
+            field_mapping={"spans": "labeled_multi_spans", "relations": "binary_relations"},
+        ),
+        trim_adus=TextSpanTrimmer(layer="labeled_multi_spans"),
+        sort_symmetric_relation_arguments=RelationArgumentSorter(
+            relation_layer="binary_relations",
+            label_whitelist=["semantically_same"],
+        ),
+    )
+
+
+class SciArgConfig(BratConfig):
+    def __init__(
+        self,
+        name: str,
+        resolve_parts_of_same: bool = False,
+        **kwargs,
+    ):
+        super().__init__(name=name, merge_fragmented_spans=True, **kwargs)
+        self.resolve_parts_of_same = resolve_parts_of_same
+
+
 class SciArg(BratBuilder):
     BASE_DATASET_PATH = "DFKI-SLT/brat"
     BASE_DATASET_REVISION = "844de61e8a00dc6a93fc29dc185f6e617131fbf1"
@@ -39,33 +70,78 @@ class SciArg(BratBuilder):
     # The span fragments in SciArg come just from the new line splits, so we can merge them.
     # Actual span fragments are annotated via "parts_of_same" relations.
     BUILDER_CONFIGS = [
-        BratConfig(name=BratBuilder.DEFAULT_CONFIG_NAME, merge_fragmented_spans=True),
+        SciArgConfig(name=BratBuilder.DEFAULT_CONFIG_NAME),
+        SciArgConfig(name="resolve_parts_of_same", resolve_parts_of_same=True),
     ]
     DOCUMENT_TYPES = {
         BratBuilder.DEFAULT_CONFIG_NAME: BratDocumentWithMergedSpans,
+        "resolve_parts_of_same": BratDocument,
     }
 
     # we need to add None to the list of dataset variants to support the default dataset variant
     BASE_BUILDER_KWARGS_DICT = {
         dataset_variant: {"url": URL, "split_paths": SPLIT_PATHS}
-        for dataset_variant in ["default", "merge_fragmented_spans", None]
+        for dataset_variant in ["default", "resolve_parts_of_same", None]
     }
 
-    DOCUMENT_CONVERTERS = {
-        TextDocumentWithLabeledSpansAndBinaryRelations: Pipeline(
-            **get_common_pipeline_steps(TextDocumentWithLabeledSpansAndBinaryRelations)
-        ),
-        TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions: Pipeline(
-            **get_common_pipeline_steps(
-                TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions
-            ),
-            add_partitions=RegexPartitioner(
-                partition_layer_name="labeled_partitions",
-                pattern="<([^>/]+)>.*</\\1>",
-                label_group_id=1,
-                label_whitelist=["Title", "Abstract", "H1"],
-                skip_initial_partition=True,
-                strip_whitespace=True,
-            ),
-        ),
-    }
+    def _generate_document(self, example, **kwargs):
+        document = super()._generate_document(example, **kwargs)
+        if self.config.resolve_parts_of_same:
+            document = SpansViaRelationMerger(
+                relation_layer="relations",
+                link_relation_label="parts_of_same",
+                create_multi_spans=True,
+                result_document_type=BratDocument,
+                result_field_mapping={"spans": "spans", "relations": "relations"},
+            )(document)
+        return document
+
+    @property
+    def document_converters(self) -> DocumentConvertersType:
+        regex_partitioner = RegexPartitioner(
+            partition_layer_name="labeled_partitions",
+            pattern="<([^>/]+)>.*</\\1>",
+            label_group_id=1,
+            label_whitelist=["Title", "Abstract", "H1"],
+            skip_initial_partition=True,
+            strip_whitespace=True,
+        )
+        if not self.config.resolve_parts_of_same:
+            return {
+                TextDocumentWithLabeledSpansAndBinaryRelations: Pipeline(
+                    **get_common_converter_pipeline_steps(
+                        TextDocumentWithLabeledSpansAndBinaryRelations
+                    )
+                ),
+                TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions: Pipeline(
+                    **get_common_converter_pipeline_steps(
+                        TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions
+                    ),
+                    add_partitions=regex_partitioner,
+                ),
+            }
+        else:
+            return {
+                #        TextDocumentWithLabeledSpansAndBinaryRelations: Pipeline(
+                #            **get_common_converter_pipeline_steps_with_resolve_parts_of_same(
+                #                TextDocumentWithLabeledSpansAndBinaryRelations
+                #            )
+                #        ),
+                #        TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions: Pipeline(
+                #            **get_common_converter_pipeline_steps_with_resolve_parts_of_same(
+                #                TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions
+                #            ),
+                #            add_partitions=regex_partitioner,
+                #        ),
+                TextDocumentWithLabeledMultiSpansAndBinaryRelations: Pipeline(
+                    **get_common_converter_pipeline_steps_with_resolve_parts_of_same(
+                        TextDocumentWithLabeledMultiSpansAndBinaryRelations
+                    )
+                ),
+                TextDocumentWithLabeledMultiSpansBinaryRelationsAndLabeledPartitions: Pipeline(
+                    **get_common_converter_pipeline_steps_with_resolve_parts_of_same(
+                        TextDocumentWithLabeledMultiSpansBinaryRelationsAndLabeledPartitions
+                    ),
+                    add_partitions=regex_partitioner,
+                ),
+            }