Update parquet files

.gitattributes

@@ -1,54 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text

bigbiohub.py

@@ -1,556 +0,0 @@
-from collections import defaultdict
-from dataclasses import dataclass
-from enum import Enum
-import logging
-from pathlib import Path
-from types import SimpleNamespace
-from typing import TYPE_CHECKING, Dict, Iterable, List, Tuple
-
-import datasets
-
-if TYPE_CHECKING:
-    import bioc
-
-logger = logging.getLogger(__name__)
-
-
-BigBioValues = SimpleNamespace(NULL="<BB_NULL_STR>")
-
-
-@dataclass
-class BigBioConfig(datasets.BuilderConfig):
-    """BuilderConfig for BigBio."""
-
-    name: str = None
-    version: datasets.Version = None
-    description: str = None
-    schema: str = None
-    subset_id: str = None
-
-
-class Tasks(Enum):
-    NAMED_ENTITY_RECOGNITION = "NER"
-    NAMED_ENTITY_DISAMBIGUATION = "NED"
-    EVENT_EXTRACTION = "EE"
-    RELATION_EXTRACTION = "RE"
-    COREFERENCE_RESOLUTION = "COREF"
-    QUESTION_ANSWERING = "QA"
-    TEXTUAL_ENTAILMENT = "TE"
-    SEMANTIC_SIMILARITY = "STS"
-    TEXT_PAIRS_CLASSIFICATION = "TXT2CLASS"
-    PARAPHRASING = "PARA"
-    TRANSLATION = "TRANSL"
-    SUMMARIZATION = "SUM"
-    TEXT_CLASSIFICATION = "TXTCLASS"
-
-
-entailment_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "premise": datasets.Value("string"),
-        "hypothesis": datasets.Value("string"),
-        "label": datasets.Value("string"),
-    }
-)
-
-pairs_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "document_id": datasets.Value("string"),
-        "text_1": datasets.Value("string"),
-        "text_2": datasets.Value("string"),
-        "label": datasets.Value("string"),
-    }
-)
-
-qa_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "question_id": datasets.Value("string"),
-        "document_id": datasets.Value("string"),
-        "question": datasets.Value("string"),
-        "type": datasets.Value("string"),
-        "choices": [datasets.Value("string")],
-        "context": datasets.Value("string"),
-        "answer": datasets.Sequence(datasets.Value("string")),
-    }
-)
-
-text_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "document_id": datasets.Value("string"),
-        "text": datasets.Value("string"),
-        "labels": [datasets.Value("string")],
-    }
-)
-
-text2text_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "document_id": datasets.Value("string"),
-        "text_1": datasets.Value("string"),
-        "text_2": datasets.Value("string"),
-        "text_1_name": datasets.Value("string"),
-        "text_2_name": datasets.Value("string"),
-    }
-)
-
-kb_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "document_id": datasets.Value("string"),
-        "passages": [
-            {
-                "id": datasets.Value("string"),
-                "type": datasets.Value("string"),
-                "text": datasets.Sequence(datasets.Value("string")),
-                "offsets": datasets.Sequence([datasets.Value("int32")]),
-            }
-        ],
-        "entities": [
-            {
-                "id": datasets.Value("string"),
-                "type": datasets.Value("string"),
-                "text": datasets.Sequence(datasets.Value("string")),
-                "offsets": datasets.Sequence([datasets.Value("int32")]),
-                "normalized": [
-                    {
-                        "db_name": datasets.Value("string"),
-                        "db_id": datasets.Value("string"),
-                    }
-                ],
-            }
-        ],
-        "events": [
-            {
-                "id": datasets.Value("string"),
-                "type": datasets.Value("string"),
-                # refers to the text_bound_annotation of the trigger
-                "trigger": {
-                    "text": datasets.Sequence(datasets.Value("string")),
-                    "offsets": datasets.Sequence([datasets.Value("int32")]),
-                },
-                "arguments": [
-                    {
-                        "role": datasets.Value("string"),
-                        "ref_id": datasets.Value("string"),
-                    }
-                ],
-            }
-        ],
-        "coreferences": [
-            {
-                "id": datasets.Value("string"),
-                "entity_ids": datasets.Sequence(datasets.Value("string")),
-            }
-        ],
-        "relations": [
-            {
-                "id": datasets.Value("string"),
-                "type": datasets.Value("string"),
-                "arg1_id": datasets.Value("string"),
-                "arg2_id": datasets.Value("string"),
-                "normalized": [
-                    {
-                        "db_name": datasets.Value("string"),
-                        "db_id": datasets.Value("string"),
-                    }
-                ],
-            }
-        ],
-    }
-)
-
-
-def get_texts_and_offsets_from_bioc_ann(ann: "bioc.BioCAnnotation") -> Tuple:
-
-    offsets = [(loc.offset, loc.offset + loc.length) for loc in ann.locations]
-
-    text = ann.text
-
-    if len(offsets) > 1:
-        i = 0
-        texts = []
-        for start, end in offsets:
-            chunk_len = end - start
-            texts.append(text[i : chunk_len + i])
-            i += chunk_len
-            while i < len(text) and text[i] == " ":
-                i += 1
-    else:
-        texts = [text]
-
-    return offsets, texts
-
-
-def remove_prefix(a: str, prefix: str) -> str:
-    if a.startswith(prefix):
-        a = a[len(prefix) :]
-    return a
-
-
-def parse_brat_file(
-    txt_file: Path,
-    annotation_file_suffixes: List[str] = None,
-    parse_notes: bool = False,
-) -> Dict:
-    """
-    Parse a brat file into the schema defined below.
-    `txt_file` should be the path to the brat '.txt' file you want to parse, e.g. 'data/1234.txt'
-    Assumes that the annotations are contained in one or more of the corresponding '.a1', '.a2' or '.ann' files,
-    e.g. 'data/1234.ann' or 'data/1234.a1' and 'data/1234.a2'.
-    Will include annotator notes, when `parse_notes == True`.
-    brat_features = datasets.Features(
-        {
-            "id": datasets.Value("string"),
-            "document_id": datasets.Value("string"),
-            "text": datasets.Value("string"),
-            "text_bound_annotations": [  # T line in brat, e.g. type or event trigger
-                {
-                    "offsets": datasets.Sequence([datasets.Value("int32")]),
-                    "text": datasets.Sequence(datasets.Value("string")),
-                    "type": datasets.Value("string"),
-                    "id": datasets.Value("string"),
-                }
-            ],
-            "events": [  # E line in brat
-                {
-                    "trigger": datasets.Value(
-                        "string"
-                    ),  # refers to the text_bound_annotation of the trigger,
-                    "id": datasets.Value("string"),
-                    "type": datasets.Value("string"),
-                    "arguments": datasets.Sequence(
-                        {
-                            "role": datasets.Value("string"),
-                            "ref_id": datasets.Value("string"),
-                        }
-                    ),
-                }
-            ],
-            "relations": [  # R line in brat
-                {
-                    "id": datasets.Value("string"),
-                    "head": {
-                        "ref_id": datasets.Value("string"),
-                        "role": datasets.Value("string"),
-                    },
-                    "tail": {
-                        "ref_id": datasets.Value("string"),
-                        "role": datasets.Value("string"),
-                    },
-                    "type": datasets.Value("string"),
-                }
-            ],
-            "equivalences": [  # Equiv line in brat
-                {
-                    "id": datasets.Value("string"),
-                    "ref_ids": datasets.Sequence(datasets.Value("string")),
-                }
-            ],
-            "attributes": [  # M or A lines in brat
-                {
-                    "id": datasets.Value("string"),
-                    "type": datasets.Value("string"),
-                    "ref_id": datasets.Value("string"),
-                    "value": datasets.Value("string"),
-                }
-            ],
-            "normalizations": [  # N lines in brat
-                {
-                    "id": datasets.Value("string"),
-                    "type": datasets.Value("string"),
-                    "ref_id": datasets.Value("string"),
-                    "resource_name": datasets.Value(
-                        "string"
-                    ),  # Name of the resource, e.g. "Wikipedia"
-                    "cuid": datasets.Value(
-                        "string"
-                    ),  # ID in the resource, e.g. 534366
-                    "text": datasets.Value(
-                        "string"
-                    ),  # Human readable description/name of the entity, e.g. "Barack Obama"
-                }
-            ],
-            ### OPTIONAL: Only included when `parse_notes == True`
-            "notes": [  # # lines in brat
-                {
-                    "id": datasets.Value("string"),
-                    "type": datasets.Value("string"),
-                    "ref_id": datasets.Value("string"),
-                    "text": datasets.Value("string"),
-                }
-            ],
-        },
-        )
-    """
-
-    example = {}
-    example["document_id"] = txt_file.with_suffix("").name
-    with txt_file.open() as f:
-        example["text"] = f.read()
-
-    # If no specific suffixes of the to-be-read annotation files are given - take standard suffixes
-    # for event extraction
-    if annotation_file_suffixes is None:
-        annotation_file_suffixes = [".a1", ".a2", ".ann"]
-
-    if len(annotation_file_suffixes) == 0:
-        raise AssertionError(
-            "At least one suffix for the to-be-read annotation files should be given!"
-        )
-
-    ann_lines = []
-    for suffix in annotation_file_suffixes:
-        annotation_file = txt_file.with_suffix(suffix)
-        if annotation_file.exists():
-            with annotation_file.open() as f:
-                ann_lines.extend(f.readlines())
-
-    example["text_bound_annotations"] = []
-    example["events"] = []
-    example["relations"] = []
-    example["equivalences"] = []
-    example["attributes"] = []
-    example["normalizations"] = []
-
-    if parse_notes:
-        example["notes"] = []
-
-    for line in ann_lines:
-        line = line.strip()
-        if not line:
-            continue
-
-        if line.startswith("T"):  # Text bound
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-            ann["type"] = fields[1].split()[0]
-            ann["offsets"] = []
-            span_str = remove_prefix(fields[1], (ann["type"] + " "))
-            text = fields[2]
-            for span in span_str.split(";"):
-                start, end = span.split()
-                ann["offsets"].append([int(start), int(end)])
-
-            # Heuristically split text of discontiguous entities into chunks
-            ann["text"] = []
-            if len(ann["offsets"]) > 1:
-                i = 0
-                for start, end in ann["offsets"]:
-                    chunk_len = end - start
-                    ann["text"].append(text[i : chunk_len + i])
-                    i += chunk_len
-                    while i < len(text) and text[i] == " ":
-                        i += 1
-            else:
-                ann["text"] = [text]
-
-            example["text_bound_annotations"].append(ann)
-
-        elif line.startswith("E"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-
-            ann["type"], ann["trigger"] = fields[1].split()[0].split(":")
-
-            ann["arguments"] = []
-            for role_ref_id in fields[1].split()[1:]:
-                argument = {
-                    "role": (role_ref_id.split(":"))[0],
-                    "ref_id": (role_ref_id.split(":"))[1],
-                }
-                ann["arguments"].append(argument)
-
-            example["events"].append(ann)
-
-        elif line.startswith("R"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-            ann["type"] = fields[1].split()[0]
-
-            ann["head"] = {
-                "role": fields[1].split()[1].split(":")[0],
-                "ref_id": fields[1].split()[1].split(":")[1],
-            }
-            ann["tail"] = {
-                "role": fields[1].split()[2].split(":")[0],
-                "ref_id": fields[1].split()[2].split(":")[1],
-            }
-
-            example["relations"].append(ann)
-
-        # '*' seems to be the legacy way to mark equivalences,
-        # but I couldn't find any info on the current way
-        # this might have to be adapted dependent on the brat version
-        # of the annotation
-        elif line.startswith("*"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-            ann["ref_ids"] = fields[1].split()[1:]
-
-            example["equivalences"].append(ann)
-
-        elif line.startswith("A") or line.startswith("M"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-
-            info = fields[1].split()
-            ann["type"] = info[0]
-            ann["ref_id"] = info[1]
-
-            if len(info) > 2:
-                ann["value"] = info[2]
-            else:
-                ann["value"] = ""
-
-            example["attributes"].append(ann)
-
-        elif line.startswith("N"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-            ann["text"] = fields[2]
-
-            info = fields[1].split()
-
-            ann["type"] = info[0]
-            ann["ref_id"] = info[1]
-            ann["resource_name"] = info[2].split(":")[0]
-            ann["cuid"] = info[2].split(":")[1]
-            example["normalizations"].append(ann)
-
-        elif parse_notes and line.startswith("#"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-            ann["text"] = fields[2] if len(fields) == 3 else BigBioValues.NULL
-
-            info = fields[1].split()
-
-            ann["type"] = info[0]
-            ann["ref_id"] = info[1]
-            example["notes"].append(ann)
-
-    return example
-
-
-def brat_parse_to_bigbio_kb(brat_parse: Dict) -> Dict:
-    """
-    Transform a brat parse (conforming to the standard brat schema) obtained with
-    `parse_brat_file` into a dictionary conforming to the `bigbio-kb` schema (as defined in ../schemas/kb.py)
-    :param brat_parse:
-    """
-
-    unified_example = {}
-
-    # Prefix all ids with document id to ensure global uniqueness,
-    # because brat ids are only unique within their document
-    id_prefix = brat_parse["document_id"] + "_"
-
-    # identical
-    unified_example["document_id"] = brat_parse["document_id"]
-    unified_example["passages"] = [
-        {
-            "id": id_prefix + "_text",
-            "type": "abstract",
-            "text": [brat_parse["text"]],
-            "offsets": [[0, len(brat_parse["text"])]],
-        }
-    ]
-
-    # get normalizations
-    ref_id_to_normalizations = defaultdict(list)
-    for normalization in brat_parse["normalizations"]:
-        ref_id_to_normalizations[normalization["ref_id"]].append(
-            {
-                "db_name": normalization["resource_name"],
-                "db_id": normalization["cuid"],
-            }
-        )
-
-    # separate entities and event triggers
-    unified_example["events"] = []
-    non_event_ann = brat_parse["text_bound_annotations"].copy()
-    for event in brat_parse["events"]:
-        event = event.copy()
-        event["id"] = id_prefix + event["id"]
-        trigger = next(
-            tr
-            for tr in brat_parse["text_bound_annotations"]
-            if tr["id"] == event["trigger"]
-        )
-        if trigger in non_event_ann:
-            non_event_ann.remove(trigger)
-        event["trigger"] = {
-            "text": trigger["text"].copy(),
-            "offsets": trigger["offsets"].copy(),
-        }
-        for argument in event["arguments"]:
-            argument["ref_id"] = id_prefix + argument["ref_id"]
-
-        unified_example["events"].append(event)
-
-    unified_example["entities"] = []
-    anno_ids = [ref_id["id"] for ref_id in non_event_ann]
-    for ann in non_event_ann:
-        entity_ann = ann.copy()
-        entity_ann["id"] = id_prefix + entity_ann["id"]
-        entity_ann["normalized"] = ref_id_to_normalizations[ann["id"]]
-        unified_example["entities"].append(entity_ann)
-
-    # massage relations
-    unified_example["relations"] = []
-    skipped_relations = set()
-    for ann in brat_parse["relations"]:
-        if (
-            ann["head"]["ref_id"] not in anno_ids
-            or ann["tail"]["ref_id"] not in anno_ids
-        ):
-            skipped_relations.add(ann["id"])
-            continue
-        unified_example["relations"].append(
-            {
-                "arg1_id": id_prefix + ann["head"]["ref_id"],
-                "arg2_id": id_prefix + ann["tail"]["ref_id"],
-                "id": id_prefix + ann["id"],
-                "type": ann["type"],
-                "normalized": [],
-            }
-        )
-    if len(skipped_relations) > 0:
-        example_id = brat_parse["document_id"]
-        logger.info(
-            f"Example:{example_id}: The `bigbio_kb` schema allows `relations` only between entities."
-            f" Skip (for now): "
-            f"{list(skipped_relations)}"
-        )
-
-    # get coreferences
-    unified_example["coreferences"] = []
-    for i, ann in enumerate(brat_parse["equivalences"], start=1):
-        is_entity_cluster = True
-        for ref_id in ann["ref_ids"]:
-            if not ref_id.startswith("T"):  # not textbound -> no entity
-                is_entity_cluster = False
-            elif ref_id not in anno_ids:  # event trigger -> no entity
-                is_entity_cluster = False
-        if is_entity_cluster:
-            entity_ids = [id_prefix + i for i in ann["ref_ids"]]
-            unified_example["coreferences"].append(
-                {"id": id_prefix + str(i), "entity_ids": entity_ids}
-            )
-    return unified_example

muchmore.py

@@ -1,739 +0,0 @@
-# coding=utf-8
-# Copyright 2022 The HuggingFace Datasets Authors and the current dataset script contributor.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-A dataset loader for the MuchMore Springer Bilingual Corpus
-
-homepage
-
-* https://muchmore.dfki.de/resources1.htm
-
-description of annotation format
-
-* https://muchmore.dfki.de/pubs/D4.1.pdf
-
-Four files are distributed
-
-* springer_english_train_plain.tar.gz (english plain text of abstracts)
-* springer_german_train_plain.tar.gz (german plain text of abstracts)
-* springer_english_train_V4.2.tar.gz (annotated xml in english)
-* springer_german_train_V4.2.tar.gz (annotated xml in german)
-
-Each tar file has one member file per abstract.
-There are keys to join the english and german files
-but there is not a 1-1 mapping between them (i.e. some
-english files have no german counterpart and some german
-files have no english counterpart). However, there is a 1-1
-mapping between plain text and annotations for a given language
-(i.e. an abstract in springer_english_train_plain.tar.gz will
-also be found in springer_english_train_V4.2.tar.gz)
-
-Counts,
-
-* 15,631 total abstracts
-* 7,823 english abstracts
-* 7,808 german abstracts
-* 6,374 matched (en/de) abstracts
-* 1,449 english abstracts with no german
-* 1,434 german abstracts with no english
-
-Notes
-
-* Arthroskopie.00130237.eng.abstr.chunkmorph.annotated.xml seems to be empty
-
-
-* entity spans can overlap. an example from the first sample:
-
-{'id': 'Arthroskopie.00130003.eng.abstr-s1-t1',
-  'type': 'umlsterm',
-  'text': ['posterior'],
-  'offsets': [[4, 13]],
-  'normalized': [{'db_name': 'UMLS', 'db_id': 'C0032009'}]},
-{'id': 'Arthroskopie.00130003.eng.abstr-s1-t8',
-  'type': 'umlsterm',
-  'text': ['posterior cruciate ligament'],
-  'offsets': [[4, 31]],
-  'normalized': [{'db_name': 'UMLS', 'db_id': 'C0080039'}]},
-{'id': 'Arthroskopie.00130003.eng.abstr-s1-t2',
-  'type': 'umlsterm',
-  'text': ['ligament'],
-  'offsets': [[23, 31]],
-  'normalized': [{'db_name': 'UMLS', 'db_id': 'C0023685'},
-   {'db_name': 'UMLS', 'db_id': 'C0023686'}]},
-
-
-* semantic relations are defined beween concepts but entities can
-  have multiple concpets associated with them. in the bigbio
-  schema we skip relations between multiple concept of the
-  same entity. an example of a relation that is kept from the
-  source schema is below,
-
-In [35]: dsd['train'][0]['sentences'][0]['tokens']
-Out[35]:
-[{'id': 'w1', 'pos': 'DT', 'lemma': 'the', 'text': 'The'},
- {'id': 'w2', 'pos': 'JJ', 'lemma': 'posterior', 'text': 'posterior'},
- {'id': 'w3', 'pos': 'JJ', 'lemma': 'cruciate', 'text': 'cruciate'},
- {'id': 'w4', 'pos': 'NN', 'lemma': 'ligament', 'text': 'ligament'},
- {'id': 'w5', 'pos': 'PUNCT', 'lemma': None, 'text': '('},
- {'id': 'w6', 'pos': 'NN', 'lemma': None, 'text': 'PCL'},
- {'id': 'w7', 'pos': 'PUNCT', 'lemma': None, 'text': ')'},
- {'id': 'w8', 'pos': 'VBZ', 'lemma': 'be', 'text': 'is'},
- {'id': 'w9', 'pos': 'DT', 'lemma': 'the', 'text': 'the'},
- {'id': 'w10', 'pos': 'JJS', 'lemma': 'strong', 'text': 'strongest'},
- {'id': 'w11', 'pos': 'NN', 'lemma': 'ligament', 'text': 'ligament'},
- {'id': 'w12', 'pos': 'IN', 'lemma': 'of', 'text': 'of'},
- {'id': 'w13', 'pos': 'DT', 'lemma': 'the', 'text': 'the'},
- {'id': 'w14', 'pos': 'JJ', 'lemma': 'human', 'text': 'human'},
- {'id': 'w15', 'pos': 'NN', 'lemma': 'knee', 'text': 'knee'},
- {'id': 'w16', 'pos': 'JJ', 'lemma': 'joint', 'text': 'joint'},
- {'id': 'w17', 'pos': 'PUNCT', 'lemma': None, 'text': '.'}]
-
-
-In [36]: dsd['train'][0]['sentences'][0]['semrels'][0]
-Out[36]: {'id': 'r1', 'term1': 't3.1', 'term2': 't6.1', 'reltype': 'surrounds'}
-
-In [37]: dsd['train'][0]['sentences'][0]['umlsterms'][2]
-Out[37]:
-{'id': 't3',
- 'from': 'w11',
- 'to': 'w11',
- 'concepts': [{'id': 't3.1',
-   'cui': 'C0023685',
-   'preferred': 'Ligaments',
-   'tui': 'T024',
-   'mshs': [{'code': 'A2.513'}]},
-  {'id': 't3.2',
-   'cui': 'C0023686',
-   'preferred': 'Articular ligaments',
-   'tui': 'T023',
-   'mshs': [{'code': 'A2.513.514'}, {'code': 'A2.835.583.512'}]}]}
-
-In [38]: dsd['train'][0]['sentences'][0]['umlsterms'][5]
-Out[38]:
-{'id': 't6',
- 'from': 'w16',
- 'to': 'w16',
- 'concepts': [{'id': 't6.1',
-   'cui': 'C0022417',
-   'preferred': 'Joints',
-   'tui': 'T030',
-   'mshs': [{'code': 'A2.835.583'}]}]}
-
-"""
-
-import itertools
-import os
-import re
-import tarfile
-import xml.etree.ElementTree as ET
-from collections import defaultdict
-from typing import Dict, List
-from xml.etree.ElementTree import Element
-
-import datasets
-from datasets import Features, Value
-
-# TODO: home page has a list of publications but its not clear which to choose
-# https://muchmore.dfki.de/papers1.htm
-# to start, chose the one below.
-# Buitelaar, Paul / Declerck, Thierry / Sacaleanu, Bogdan / Vintar, Spela / Raileanu, Diana / Crispi, Claudia: A Multi-Layered, XML-Based Approach to the Integration of Linguistic and Semantic Annotations. In: Proceedings of EACL 2003 Workshop on Language Technology and the Semantic Web (NLPXML’03), Budapest, Hungary, April 2003.
-from .bigbiohub import kb_features
-from .bigbiohub import text2text_features
-from .bigbiohub import BigBioConfig
-from .bigbiohub import Tasks
-
-_LANGUAGES = ['English', 'German']
-_PUBMED = True
-_LOCAL = False
-_CITATION = """\
-@inproceedings{buitelaar2003multi,
-  title={A multi-layered, xml-based approach to the integration of linguistic and semantic annotations},
-  author={Buitelaar, Paul and Declerck, Thierry and Sacaleanu, Bogdan and Vintar, {\v{S}}pela and Raileanu, Diana and Crispi, Claudia},
-  booktitle={Proceedings of EACL 2003 Workshop on Language Technology and the Semantic Web (NLPXML'03), Budapest, Hungary},
-  year={2003}
-}
-"""
-
-_DESCRIPTION = """\
-The corpus used in the MuchMore project is a parallel corpus of English-German scientific
-medical abstracts obtained from the Springer Link web site. The corpus consists
-approximately of 1 million tokens for each language. Abstracts are from 41 medical
-journals, each of which constitutes a relatively homogeneous medical sub-domain (e.g.
-Neurology, Radiology, etc.). The corpus of downloaded HTML documents is normalized in
-various ways, in order to produce a clean, plain text version, consisting of a title, abstract
-and keywords. Additionally, the corpus was aligned on the sentence level.
-
-Automatic (!) annotation includes: Part-of-Speech; Morphology (inflection and
-decomposition); Chunks; Semantic Classes (UMLS: Unified Medical Language System,
-MeSH: Medical Subject Headings, EuroWordNet); Semantic Relations from UMLS.
-"""
-
-_DATASETNAME = "muchmore"
-_DISPLAYNAME = "MuchMore"
-
-_HOMEPAGE = "https://muchmore.dfki.de/resources1.htm"
-
-# TODO: website says the following, but don't see a specific license
-# TODO: add to FAQs about what to do in this situation.
-
-# "The cross-lingual information access prototype system for the medical domain
-# will be made publicly accessible through the internet. It provides access to
-# multilingual information on the basis of a domain ontology and classification.
-# For the main task of multilingual domain modelling, the project will focus
-# on German and English. "
-_LICENSE = 'License information unavailable'
-_URLs = {
-    "muchmore_source": [
-        "https://muchmore.dfki.de/pubs/springer_english_train_plain.tar.gz",
-        "https://muchmore.dfki.de/pubs/springer_english_train_V4.2.tar.gz",
-        "https://muchmore.dfki.de/pubs/springer_german_train_plain.tar.gz",
-        "https://muchmore.dfki.de/pubs/springer_german_train_V4.2.tar.gz",
-    ],
-    "muchmore_bigbio_kb": [
-        "https://muchmore.dfki.de/pubs/springer_english_train_V4.2.tar.gz",
-        "https://muchmore.dfki.de/pubs/springer_german_train_V4.2.tar.gz",
-    ],
-    "muchmore_en_bigbio_kb": "https://muchmore.dfki.de/pubs/springer_english_train_V4.2.tar.gz",
-    "muchmore_de_bigbio_kb": "https://muchmore.dfki.de/pubs/springer_german_train_V4.2.tar.gz",
-    "plain": [
-        "https://muchmore.dfki.de/pubs/springer_english_train_plain.tar.gz",
-        "https://muchmore.dfki.de/pubs/springer_german_train_plain.tar.gz",
-    ],
-    "plain_en": "https://muchmore.dfki.de/pubs/springer_english_train_plain.tar.gz",
-    "plain_de": "https://muchmore.dfki.de/pubs/springer_german_train_plain.tar.gz",
-    "muchmore_bigbio_t2t": [
-        "https://muchmore.dfki.de/pubs/springer_english_train_plain.tar.gz",
-        "https://muchmore.dfki.de/pubs/springer_german_train_plain.tar.gz",
-    ],
-}
-
-# took version from annotated file names
-_SOURCE_VERSION = "4.2.0"
-_BIGBIO_VERSION = "1.0.0"
-_SUPPORTED_TASKS = [
-    Tasks.TRANSLATION,
-    Tasks.NAMED_ENTITY_RECOGNITION,
-    Tasks.NAMED_ENTITY_DISAMBIGUATION,
-    Tasks.RELATION_EXTRACTION,
-]
-
-NATIVE_ENCODING = "ISO-8859-1"
-FILE_NAME_PATTERN = r"^(.+?)\.(eng|ger)\.abstr(\.chunkmorph\.annotated\.xml)?$"
-LANG_MAP = {"eng": "en", "ger": "de"}
-
-
-class MuchMoreDataset(datasets.GeneratorBasedBuilder):
-    """MuchMore Springer Bilingual Corpus"""
-
-    DEFAULT_CONFIG_NAME = "muchmore_source"
-    SOURCE_VERSION = datasets.Version(_SOURCE_VERSION)
-    BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION)
-
-    BUILDER_CONFIGS = [
-        BigBioConfig(
-            name="muchmore_source",
-            version=SOURCE_VERSION,
-            description="MuchMore source schema",
-            schema="source",
-            subset_id="muchmore",
-        ),
-        BigBioConfig(
-            name="muchmore_bigbio_kb",
-            version=BIGBIO_VERSION,
-            description="MuchMore simplified BigBio kb schema",
-            schema="bigbio_kb",
-            subset_id="muchmore",
-        ),
-        BigBioConfig(
-            name="muchmore_en_bigbio_kb",
-            version=BIGBIO_VERSION,
-            description="MuchMore simplified BigBio kb schema",
-            schema="bigbio_kb",
-            subset_id="muchmore_en",
-        ),
-        BigBioConfig(
-            name="muchmore_de_bigbio_kb",
-            version=BIGBIO_VERSION,
-            description="MuchMore simplified BigBio kb schema",
-            schema="bigbio_kb",
-            subset_id="muchmore_de",
-        ),
-        BigBioConfig(
-            name="muchmore_bigbio_t2t",
-            version=BIGBIO_VERSION,
-            description="MuchMore simplified BigBio translation schema",
-            schema="bigbio_t2t",
-            subset_id="muchmore",
-        ),
-    ]
-
-    # default config produces english annotations at the moment
-    def _info(self):
-
-        if self.config.schema == "source":
-            features = Features(
-                {
-                    "sample_id": Value("string"),
-                    "corresp": Value("string"),
-                    "language": Value("string"),
-                    "abstract": Value("string"),
-                    "sentences": [
-                        {
-                            "id": Value("string"),
-                            "corresp": Value("string"),
-                            "umlsterms": [
-                                {
-                                    "id": Value("string"),
-                                    "from": Value("string"),
-                                    "to": Value("string"),
-                                    "concepts": [
-                                        {
-                                            "id": Value("string"),
-                                            "cui": Value("string"),
-                                            "preferred": Value("string"),
-                                            "tui": Value("string"),
-                                            "mshs": [
-                                                {
-                                                    "code": Value("string"),
-                                                }
-                                            ],
-                                        }
-                                    ],
-                                }
-                            ],
-                            "ewnterms": [
-                                {
-                                    "id": Value("string"),
-                                    "to": Value("string"),
-                                    "from": Value("string"),
-                                    "senses": [
-                                        {
-                                            "offset": Value("string"),
-                                        }
-                                    ],
-                                }
-                            ],
-                            "semrels": [
-                                {
-                                    "id": Value("string"),
-                                    "term1": Value("string"),
-                                    "term2": Value("string"),
-                                    "reltype": Value("string"),
-                                }
-                            ],
-                            "chunks": [
-                                {
-                                    "id": Value("string"),
-                                    "to": Value("string"),
-                                    "from": Value("string"),
-                                    "type": Value("string"),
-                                }
-                            ],
-                            "tokens": [
-                                {
-                                    "id": Value("string"),
-                                    "pos": Value("string"),
-                                    "lemma": Value("string"),
-                                    "text": Value("string"),
-                                }
-                            ],
-                        }
-                    ],
-                }
-            )
-
-        elif self.config.schema == "bigbio_kb":
-            features = kb_features
-
-        elif self.config.name in ("plain", "plain_en", "plain_de"):
-            features = Features(
-                {
-                    "sample_id": Value("string"),
-                    "sample_id_prefix": Value("string"),
-                    "language": Value("string"),
-                    "abstract": Value("string"),
-                }
-            )
-
-        elif self.config.schema == "bigbio_t2t":
-            features = text2text_features
-
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            supervised_keys=None,
-            homepage=_HOMEPAGE,
-            license=str(_LICENSE),
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        """Returns SplitGenerators."""
-        my_urls = _URLs[self.config.name]
-        data_dirs = dl_manager.download(my_urls)
-        # ensure that data_dirs is always a list of string paths
-        if isinstance(data_dirs, str):
-            data_dirs = [data_dirs]
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "file_names_and_pointers": itertools.chain(
-                        *[dl_manager.iter_archive(data_dir) for data_dir in data_dirs]
-                    ),
-                    "split": "train",
-                },
-            ),
-        ]
-
-    @staticmethod
-    def _get_umlsterms_from_xsent(xsent: Element) -> List:
-        xumlsterms = xsent.find("./umlsterms")
-
-        umlsterms = []
-        for xumlsterm in xumlsterms.findall("./umlsterm"):
-
-            concepts = []
-            for xconcept in xumlsterm.findall("./concept"):
-
-                mshs = [
-                    {"code": xmsh.get("code")} for xmsh in xconcept.findall("./msh")
-                ]
-
-                concept = {
-                    "id": xconcept.get("id"),
-                    "cui": xconcept.get("cui"),
-                    "preferred": xconcept.get("preferred"),
-                    "tui": xconcept.get("tui"),
-                    "mshs": mshs,
-                }
-                concepts.append(concept)
-
-            umlsterm = {
-                "id": xumlsterm.get("id"),
-                "from": xumlsterm.get("from"),
-                "to": xumlsterm.get("to"),
-                "concepts": concepts,
-            }
-            umlsterms.append(umlsterm)
-
-        return umlsterms
-
-    @staticmethod
-    def _get_ewnterms_from_xsent(xsent: Element) -> List:
-        xewnterms = xsent.find("./ewnterms")
-
-        ewnterms = []
-        for xewnterm in xewnterms.findall("./ewnterm"):
-
-            senses = [
-                {"offset": xsense.get("offset")}
-                for xsense in xewnterm.findall("./sense")
-            ]
-
-            ewnterm = {
-                "id": xewnterm.get("id"),
-                "from": xewnterm.get("from"),
-                "to": xewnterm.get("to"),
-                "senses": senses,
-            }
-            ewnterms.append(ewnterm)
-
-        return ewnterms
-
-    @staticmethod
-    def _get_semrels_from_xsent(xsent: Element) -> List[Dict[str, str]]:
-        xsemrels = xsent.find("./semrels")
-        return [
-            {
-                "id": xsemrel.get("id"),
-                "term1": xsemrel.get("term1"),
-                "term2": xsemrel.get("term2"),
-                "reltype": xsemrel.get("reltype"),
-            }
-            for xsemrel in xsemrels.findall("./semrel")
-        ]
-
-    @staticmethod
-    def _get_chunks_from_xsent(xsent: Element) -> List[Dict[str, str]]:
-        xchunks = xsent.find("./chunks")
-        return [
-            {
-                "id": xchunk.get("id"),
-                "to": xchunk.get("to"),
-                "from": xchunk.get("from"),
-                "type": xchunk.get("type"),
-            }
-            for xchunk in xchunks.findall("./chunk")
-        ]
-
-    @staticmethod
-    def _get_tokens_from_xsent(xsent: Element) -> List[Dict[str, str]]:
-        xtext = xsent.find("./text")
-        return [
-            {
-                "id": xtoken.get("id"),
-                "pos": xtoken.get("pos"),
-                "lemma": xtoken.get("lemma"),
-                "text": xtoken.text,
-            }
-            for xtoken in xtext.findall("./token")
-        ]
-
-    def _generate_original_examples(self, file_names_and_pointers):
-        """Generate something close to the original dataset.
-
-        This will yield one sample per abstract with the plaintext
-        and the annotations combined into one object. If an abstract
-        is available in both english and german each language version
-        will be a distinct example.
-        """
-        abstracts = {}
-        samples = {}
-        for file_name, fp in file_names_and_pointers:
-
-            if file_name.endswith(".abstr"):
-                sample_id = file_name
-                abstracts[sample_id] = fp.read().decode(NATIVE_ENCODING)
-
-            elif file_name.endswith(".abstr.chunkmorph.annotated.xml"):
-                content_bytes = fp.read()
-                content_str = content_bytes.decode(NATIVE_ENCODING)
-                if content_str == "":
-                    continue
-
-                xroot = ET.fromstring(content_str)
-
-                sentences = []
-                for xsent in xroot.findall("./"):
-                    sentence = {
-                        "id": xsent.get("id"),
-                        "corresp": xsent.get("corresp"),
-                        "umlsterms": self._get_umlsterms_from_xsent(xsent),
-                        "ewnterms": self._get_ewnterms_from_xsent(xsent),
-                        "semrels": self._get_semrels_from_xsent(xsent),
-                        "chunks": self._get_chunks_from_xsent(xsent),
-                        "tokens": self._get_tokens_from_xsent(xsent),
-                    }
-                    sentences.append(sentence)
-
-                sample_id = xroot.get("id")
-                samples[sample_id] = {
-                    "sample_id": sample_id,
-                    "corresp": xroot.get("corresp"),
-                    "language": xroot.get("lang"),
-                    "sentences": sentences,
-                }
-
-        for _id, (sample_id, sample) in enumerate(samples.items()):
-            sample["abstract"] = abstracts[sample_id]
-            yield _id, sample
-
-    def _generate_bigbio_kb_examples(self, file_names_and_pointers):
-        """Generate big science biomedical kb examples."""
-
-        def snippets_tokens_from_sents(sentences):
-            snippets = []
-            for sentence in sentences:
-                snippet = [el["text"] for el in sentence["tokens"]]
-                snippets.append(snippet)
-            return snippets
-
-        def sid_to_text_off(sid, snip_txts_lens):
-            ii_sid = int(sid[1:])
-            start = sum(snip_txts_lens[: ii_sid - 1]) + (ii_sid - 1)
-            end = start + snip_txts_lens[ii_sid - 1]
-            return start, end
-
-        def sid_wid_to_text_off(sid, wid, snip_txts_lens, snip_toks_lens):
-            s_start, s_end = sid_to_text_off(sid, snip_txts_lens)
-            ii_sid = int(sid[1:])
-            ii_wid = int(wid[1:])
-            w_start = sum(snip_toks_lens[ii_sid - 1][: ii_wid - 1]) + (ii_wid - 1)
-            start = s_start + w_start
-            end = start + snip_toks_lens[ii_sid - 1][ii_wid - 1]
-            return start, end
-
-        for _id, (file_name, fp) in enumerate(file_names_and_pointers):
-
-            content_bytes = fp.read()
-            content_str = content_bytes.decode(NATIVE_ENCODING)
-            if content_str == "":
-                continue
-
-            xroot = ET.fromstring(content_str)
-
-            sentences = []
-            for xsent in xroot.findall("./"):
-                sentence = {
-                    "id": xsent.get("id"),
-                    "corresp": xsent.get("corresp"),
-                    "umlsterms": self._get_umlsterms_from_xsent(xsent),
-                    "ewnterms": self._get_ewnterms_from_xsent(xsent),
-                    "semrels": self._get_semrels_from_xsent(xsent),
-                    "chunks": self._get_chunks_from_xsent(xsent),
-                    "tokens": self._get_tokens_from_xsent(xsent),
-                }
-                sentences.append(sentence)
-
-            snip_toks = snippets_tokens_from_sents(sentences)
-            snip_txts = [" ".join(snip_tok) for snip_tok in snip_toks]
-            snip_txts_lens = [len(el) for el in snip_txts]
-            snip_toks_lens = [[len(tok) for tok in snip] for snip in snip_toks]
-            text = " ".join(snip_txts)
-            passages = [
-                {
-                    "id": "{}-passage-0".format(xroot.get("id")),
-                    "type": "abstract",
-                    "text": [text],
-                    "offsets": [(0, len(text))],
-                }
-            ]
-
-            entities = []
-            rel_map = {}
-            for sentence in sentences:
-                sid = sentence["id"]
-                ii_sid = int(sid[1:])
-
-                for umlsterm in sentence["umlsterms"]:
-                    umlsterm_id = umlsterm["id"]
-                    entity_id = f"{sid}-{umlsterm_id}"
-                    wid_from = umlsterm["from"]
-                    wid_to = umlsterm["to"]
-                    ii_wid_from = int(wid_from[1:])
-                    ii_wid_to = int(wid_to[1:])
-
-                    tok_text = " ".join(
-                        snip_toks[ii_sid - 1][ii_wid_from - 1 : ii_wid_to]
-                    )
-                    w_from_start, w_from_end = sid_wid_to_text_off(
-                        sid, wid_from, snip_txts_lens, snip_toks_lens
-                    )
-                    w_to_start, w_to_end = sid_wid_to_text_off(
-                        sid, wid_to, snip_txts_lens, snip_toks_lens
-                    )
-
-                    offsets = [(w_from_start, w_to_end)]
-                    main_text = text[w_from_start:w_to_end]
-                    umls_cuis = [el["cui"] for el in umlsterm["concepts"]]
-                    for concept in umlsterm["concepts"]:
-                        rel_map[concept["id"]] = entity_id
-
-                    entity = {
-                        "id": "{}-{}".format(xroot.get("id"), entity_id),
-                        "offsets": offsets,
-                        "text": [tok_text],
-                        "type": "umlsterm",
-                        "normalized": [
-                            {"db_name": "UMLS", "db_id": cui} for cui in umls_cuis
-                        ],
-                    }
-                    entities.append(entity)
-
-            relations = []
-            for sentence in sentences:
-                sid = sentence["id"]
-                for semrel in sentence["semrels"]:
-                    semrel_id = semrel["id"]
-                    rel_id = "{}-{}-{}-{}".format(
-                        sid, semrel_id, semrel["term1"], semrel["term2"],
-                    )
-                    arg1_id = "{}-{}".format(xroot.get("id"), rel_map[semrel["term1"]])
-                    arg2_id = "{}-{}".format(xroot.get("id"), rel_map[semrel["term2"]])
-                    # some semrels are between multiple normalizations of
-                    # a single entity. we skip these. see docstring at top
-                    # of module for more complete description
-                    if arg1_id == arg2_id:
-                        continue
-                    relation = {
-                        "id": "{}-{}".format(xroot.get("id"), rel_id),
-                        "type": semrel["reltype"],
-                        "arg1_id": arg1_id,
-                        "arg2_id": arg2_id,
-                        "normalized": []
-                    }
-                    relations.append(relation)
-
-            yield _id, {
-                "id": xroot.get("id"),
-                "document_id": xroot.get("id"),
-                "passages": passages,
-                "entities": entities,
-                "coreferences": [],
-                "events": [],
-                "relations": relations,
-            }
-
-    def _generate_plain_examples(self, file_names_and_pointers):
-        """Generate plain text abstract examples."""
-        for _id, (file_name, fp) in enumerate(file_names_and_pointers):
-            match = re.match(FILE_NAME_PATTERN, file_name)
-            yield _id, {
-                "sample_id_prefix": match.group(1),
-                "sample_id": file_name,
-                "language": LANG_MAP[match.group(2)],
-                "abstract": fp.read().decode(NATIVE_ENCODING),
-            }
-
-    def _generate_translation_examples(self, file_names_and_pointers):
-        sample_map = defaultdict(list)
-        for file_name, fp in file_names_and_pointers:
-            if file_name.endswith("eng.abstr"):
-                language = "en"
-            elif file_name.endswith("ger.abstr"):
-                language = "de"
-            else:
-                raise ValueError()
-            sample_id_prefix = re.sub(".(eng|ger).abstr$", "", file_name)
-            sample_id = file_name
-            abstract = fp.read().decode(NATIVE_ENCODING)
-            sample_map[sample_id_prefix].append(
-                {"language": language, "sample_id": sample_id, "abstract": abstract}
-            )
-
-        _id = 0
-        for sample_id_prefix, sample_pair in sample_map.items():
-            if len(sample_pair) != 2:
-                continue
-            en_idx = 0 if sample_pair[0]["language"] == "en" else 1
-            de_idx = 0 if en_idx == 1 else 1
-            yield _id, {
-                "id": sample_id_prefix,
-                "document_id": sample_id_prefix,
-                "text_1": sample_pair[en_idx]["abstract"],
-                "text_2": sample_pair[de_idx]["abstract"],
-                "text_1_name": "en",
-                "text_2_name": "de",
-            }
-            _id += 1
-
-    def _generate_examples(self, file_names_and_pointers, split):
-
-        if self.config.schema == "source":
-            genny = self._generate_original_examples(file_names_and_pointers)
-
-        elif self.config.schema == "bigbio_kb":
-            genny = self._generate_bigbio_kb_examples(file_names_and_pointers)
-
-        elif self.config.name in ("plain", "plain_en", "plain_de"):
-            genny = self._generate_plain_examples(file_names_and_pointers)
-
-        elif self.config.schema == "bigbio_t2t":
-            genny = self._generate_translation_examples(file_names_and_pointers)
-
-        for _id, sample in genny:
-            yield _id, sample

muchmore_bigbio_kb/muchmore-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21ecb6aec0fb7ff6f8911490aba2567d11c85a4930caf5728fea8e6bd612dcc3
+size 26127505

muchmore_bigbio_t2t/muchmore-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06f692a8fc0ea9bb2afeef613b56031a28a07f759ffa82c94d7f388eebf9da0d
+size 7453621

muchmore_de_bigbio_kb/muchmore-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:beff97acdc3cec4e0f657e74a985235eb4065314fb890a7152295a4861d652c2
+size 9711777

muchmore_en_bigbio_kb/muchmore-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70af152cab3ab77d8b55c036877674a9b495023e9cb58726b16ea333a6887826
+size 16432783

muchmore_source/muchmore-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:009e0d0d49ac00e49070ba7a0bc9ce7f1dd525c0eaa2ebab19fd86834a8bfb5c
+size 38974300