first iteration of the nordmann2023 dataset on huggingface

README.md

@@ -0,0 +1,52 @@
+---
+annotations_creators: []
+language:
+- de
+- en
+language_creators: []
+license:
+- unknown
+multilinguality:
+- translation
+pretty_name: nordmann2023
+size_categories:
+- 1M<n<10M
+source_datasets: []
+tags:
+- europarl
+- newscommentary
+- wikititles
+- ecb
+- rapid
+- eesc
+- ema
+- europat
+- books
+- ted2020
+- qed
+- eubookshop
+task_categories:
+- translation
+task_ids: []
+dataset_info:
+  features:
+  - name: translation
+    dtype:
+      translation:
+        languages:
+        - de
+        - en
+  config_name: balanced
+  splits:
+  - name: train
+    num_bytes: 1539472445
+    num_examples: 5656659
+  - name: validation
+    num_bytes: 706611
+    num_examples: 2754
+  - name: test
+    num_bytes: 411077
+    num_examples: 1831
+  download_size: 4076594396
+  dataset_size: 1540590133
+---

build_tokenizer.py

@@ -0,0 +1,79 @@
+from tokenizers.decoders import WordPiece as WordPieceDecoder
+from tokenizers.pre_tokenizers import BertPreTokenizer
+from tokenizers.normalizers import BertNormalizer
+from tokenizers.trainers import WordPieceTrainer
+from tokenizers.models import WordPiece as WordPieceModel
+from tokenizers import Tokenizer
+import itertools
+
+from datasets import load_dataset
+from datasets.utils.logging import set_verbosity_error
+set_verbosity_error()
+
+from utils import SampleBatch
+
+def unpack_samples(
+    batch: SampleBatch
+):
+    iterator = (
+        sample.values()
+        for sample in batch['translation']
+    )
+
+    return list(
+        itertools.chain
+        .from_iterable(iterator)
+    )
+
+
+def build_tokenizer(
+    clean_text: bool = True,
+    strip_accents: bool = True,
+    lowercase: bool = True
+) -> Tokenizer:
+    tokenizer = Tokenizer(
+        model=WordPieceModel(
+            unk_token='<UNK>'
+        )
+    )
+    tokenizer.normalizer = BertNormalizer(
+        clean_text=clean_text,
+        handle_chinese_chars=True,
+        strip_accents=strip_accents,
+        lowercase=lowercase
+    )
+    tokenizer.pre_tokenizer = BertPreTokenizer()
+    tokenizer.decoder = WordPieceDecoder()
+
+    return tokenizer
+
+
+train_dset = load_dataset(
+    path='nordmann2023',
+    name='balanced',
+    split='train'
+)
+
+tokenizer = build_tokenizer(
+    clean_text=True,
+    strip_accents=False,
+    lowercase=False
+)
+tokenizer.train_from_iterator(
+    iterator=(
+        unpack_samples(batch)
+        for batch in train_dset.iter(
+            batch_size=10000
+        )
+    ),
+    trainer=WordPieceTrainer(
+        vocab_size=40000,
+        special_tokens=[
+            '<UNK>', '<CLS>', '<SEP>', '<PAD>', '<MASK>'
+        ]
+    ),
+    length=train_dset.num_rows * 2
+)
+tokenizer.save(
+    path='tokenizer.json'
+)

nordmann2023.py

@@ -0,0 +1,377 @@
+from typing import Optional, Callable, List, Dict, Any, Tuple, Generator
+from dataclasses import dataclass
+import itertools
+import os
+import datasets
+from .utils import Sample, list_keyby, parse_tmx, parse_sgm, parse_tsv, cleanup, normalize, dict_map, dict_filter_keys, dict_flatten
+
+logger = datasets.logging.get_logger(
+    name=__name__
+)
+
+@dataclass(frozen=True)
+class Candidate:
+    name: str
+    url: str
+    paths: Tuple[str, ...]
+    num_examples: int
+    parser: Callable[
+        [Tuple[str, ...]], Generator[Sample, None, None]
+    ]
+
+    def download_paths(
+        self,
+        base_path: str
+    ):
+        return tuple(
+            os.path.join(base_path, path)
+            for path in self.paths
+        )
+
+
+@dataclass(frozen=True)
+class Constraint:
+    start: Optional[int] = None
+    stop: Optional[int] = None
+    step: Optional[int] = None
+
+
+_CANDIDATES = [
+    Candidate(
+        name='europarl_v10',
+        url='https://statmt.org/europarl/v10/training/europarl-v10.de-en.tsv.gz',
+        paths=('.',),
+        num_examples=1828521,
+        parser=lambda filepaths: parse_tsv(
+            filepaths=filepaths,
+            columns={
+                'de': 0, 'en': 1
+            }
+        )
+    ),
+    Candidate(
+        name='newscommentary_v17',
+        url='https://www.statmt.org/news-commentary/v17/training/news-commentary-v17.de-en.tsv.gz',
+        paths=('.',),
+        num_examples=418621,
+        parser=lambda filepaths: parse_tsv(
+            filepaths=filepaths,
+            columns={
+                'de': 0, 'en': 1
+            }
+        )
+    ),
+    Candidate(
+        name='wikititles_v3',
+        url='https://object.pouta.csc.fi/OPUS-WikiTitles/v3/tmx/de-en.tmx.gz',
+        paths=('.',),
+        num_examples=1386770,
+        parser=lambda filepaths: parse_tmx(
+            filepaths=filepaths,
+            attributes={
+                'de': 'xml:lang="de"', 'en': 'xml:lang="en"',
+            }
+        )
+    ),
+    Candidate(
+        name='ecb_2017',
+        url='https://s3-eu-west-1.amazonaws.com/tilde-model/ecb2017.de-en.tmx.zip',
+        paths=('ecb2017.UNIQUE.de-en.tmx',),
+        num_examples=4147,
+        parser=lambda filepaths: parse_tmx(
+            filepaths=filepaths,
+            attributes={
+                'de': 'xml:lang="de"', 'en': 'xml:lang="en"',
+            }
+        )
+    ),
+    Candidate(
+        name='rapid_2019',
+        url='https://s3-eu-west-1.amazonaws.com/tilde-model/rapid2019.de-en.tmx.zip',
+        paths=('RAPID_2019.UNIQUE.de-en.tmx',),
+        num_examples=939808,
+        parser=lambda filepaths: parse_tmx(
+            filepaths=filepaths,
+            attributes={
+                'de': 'xml:lang="de"', 'en': 'xml:lang="en"',
+            }
+        )
+    ),
+    Candidate(
+        name='eesc_2017',
+        url='https://s3-eu-west-1.amazonaws.com/tilde-model/EESC2017.de-en.tmx.zip',
+        paths=('EESC.de-en.tmx',),
+        num_examples=2857850,
+        parser=lambda filepaths: parse_tmx(
+            filepaths=filepaths,
+            attributes={
+                'de': 'xml:lang="de"', 'en': 'xml:lang="en"',
+            }
+        )
+    ),
+    Candidate(
+        name='ema_2016',
+        url='https://s3-eu-west-1.amazonaws.com/tilde-model/EMA2016.de-en.tmx.zip',
+        paths=('EMEA2016.de-en.tmx',),
+        num_examples=347631,
+        parser=lambda filepaths: parse_tmx(
+            filepaths=filepaths,
+            attributes={
+                'de': 'xml:lang="de"', 'en': 'xml:lang="en"',
+            }
+        )
+    ),
+    Candidate(
+        name='europat_v3',
+        url='https://web-language-models.s3.amazonaws.com/europat/release3/de-en.txt.gz',
+        paths=('.',),
+        num_examples=19734742,
+        parser=lambda filepaths: parse_tsv(
+            filepaths=filepaths,
+            columns={
+                'de': 0, 'en': 1
+            }
+        )
+    ),
+    Candidate(
+        name='books_v1',
+        url='https://object.pouta.csc.fi/OPUS-Books/v1/tmx/de-en.tmx.gz',
+        paths=('.',),
+        num_examples=51106,
+        parser=lambda filepaths: parse_tmx(
+            filepaths=filepaths,
+            attributes={
+                'de': 'xml:lang="de"', 'en': 'xml:lang="en"',
+            }
+        )
+    ),
+    Candidate(
+        name='ted2020_v1',
+        url='https://object.pouta.csc.fi/OPUS-TED2020/v1/tmx/de-en.tmx.gz',
+        paths=('.',),
+        num_examples=289374,
+        parser=lambda filepaths: parse_tmx(
+            filepaths=filepaths,
+            attributes={
+                'de': 'xml:lang="de"', 'en': 'xml:lang="en"',
+            }
+        )
+    ),
+    Candidate(
+        name='qed_v2',
+        url='https://object.pouta.csc.fi/OPUS-QED/v2.0a/tmx/de-en.tmx.gz',
+        paths=('.',),
+        num_examples=492811,
+        parser=lambda filepaths: parse_tmx(
+            filepaths=filepaths,
+            attributes={
+                'de': 'xml:lang="de"', 'en': 'xml:lang="en"',
+            }
+        )
+    ),
+    Candidate(
+        name='eubookshop_v2',
+        url='https://object.pouta.csc.fi/OPUS-EUbookshop/v2/tmx/de-en.tmx.gz',
+        paths=('.',),
+        num_examples=8312724,
+        parser=lambda filepaths: parse_tmx(
+            filepaths=filepaths,
+            attributes={
+                'de': 'xml:lang="de"', 'en': 'xml:lang="en"',
+            }
+        )
+    ),
+    Candidate(
+        name='newstest2018',
+        url='https://data.statmt.org/wmt22/translation-task/dev.tgz',
+        paths=('dev/sgm/newstest2018-deen-src.de.sgm',
+               'dev/sgm/newstest2018-deen-ref.en.sgm'),
+        num_examples=2998,
+        parser=lambda filepaths: parse_sgm(
+            filepaths=filepaths,
+            files={
+                'de': 0, 'en': 1
+            }
+        )
+    ),
+    Candidate(
+        name='newstest2019',
+        url='https://data.statmt.org/wmt22/translation-task/dev.tgz',
+        paths=('dev/sgm/newstest2019-deen-src.de.sgm',
+               'dev/sgm/newstest2019-deen-ref.en.sgm'),
+        num_examples=2000,
+        parser=lambda filepaths: parse_sgm(
+            filepaths=filepaths,
+            files={
+                'de': 0, 'en': 1
+            }
+        )
+    )
+]
+
+_CANDIDATES_BY_NAME = list_keyby(
+    input=_CANDIDATES,
+    key_fn=lambda candidate: candidate.name
+)
+
+
+class NordmannConfig(
+    datasets.BuilderConfig
+):
+    def __init__(
+        self,
+        splits: Dict[datasets.NamedSplit, List[str]],
+        constraints: Dict[str, Constraint],
+        normalizer: Callable[[Sample], Sample],
+        filter: Callable[[Sample], bool],
+        **kwargs: Any
+    ):
+        assert splits
+
+        datasets.BuilderConfig.__init__(
+            self, **kwargs
+        )
+
+        self.splits = dict_map(
+            input=splits, map_fn=lambda key, value: (
+                key, dict_filter_keys(
+                    input=_CANDIDATES_BY_NAME, keys=value
+                )
+            )
+        )
+        self.constraints = constraints
+        self.normalizer = normalizer
+        self.filter = filter
+
+
+class Nordmann(
+    datasets.GeneratorBasedBuilder
+):
+    BUILDER_CONFIG_CLASS = NordmannConfig
+    BUILDER_CONFIGS = [
+        NordmannConfig(
+            name='balanced',
+            description='NORDMANN 2023 (balanced) translation task dataset.',
+            version=datasets.Version(
+                version_str='0.0.1'
+            ),
+            splits={
+                datasets.Split.TRAIN: [
+                    'europarl_v10',
+                    'newscommentary_v17',
+                    'wikititles_v3',
+                    'europat_v3',
+                    'books_v1',
+                    'ted2020_v1',
+                    'qed_v2',
+                    'eubookshop_v2'
+                ],
+                datasets.Split.VALIDATION: [
+                    'newstest2018'
+                ],
+                datasets.Split.TEST: [
+                    'newstest2019'
+                ]
+            },
+            constraints={
+                'europat_v3': Constraint(stop=1000000),
+                'eubookshop_v2': Constraint(stop=2000000)
+            },
+            normalizer=normalize(
+                strip_whitespaces=True,
+                clean_control_characters=True,
+                enforce_unicode_form='NFC'
+            ),
+            filter=cleanup(
+                length_min=4,
+                length_max=4096,
+                length_ratio_max=1.33,
+                alpha_ratio_min=.5
+            )
+        )
+    ]
+
+    def _info(
+        self
+    ):
+        features = {
+            'translation': datasets.features.Translation(
+                languages=['de', 'en']
+            )
+        }
+
+        return datasets.DatasetInfo(
+            description='Translation dataset based on statmt.org',
+            features=datasets.Features(features)
+        )
+
+    def _split_generators(
+        self,
+        dl_manager: datasets.DownloadManager
+    ):
+        self.config: NordmannConfig
+
+        urls = dict_map(
+            input=dict_flatten(
+                input=self.config.splits
+            ),
+            map_fn=lambda key, value: (
+                key, value.url
+            )
+        )
+
+        base_paths: Dict[str, str]
+        base_paths = dl_manager.download_and_extract(
+            url_or_urls=urls
+        )
+
+        generators: List[datasets.SplitGenerator]
+        generators = list()
+        for split, split_candidates in self.config.splits.items():
+            generators.append(
+                datasets.SplitGenerator(
+                    name=str(split),
+                    gen_kwargs={
+                        'candidates': split_candidates,
+                        'base_paths': base_paths
+                    }
+                )
+            )
+
+        return generators
+
+    def _generate_examples(
+        self,
+        candidates: Dict[str, Candidate],
+        base_paths: Dict[str, str]
+    ):
+        self.config: NordmannConfig
+
+        for name, candidate in candidates.items():
+            constraint = (
+                self.config.constraints[name]
+                if name in self.config.constraints else Constraint()
+            )
+
+            samples = candidate.parser(
+                candidate.download_paths(
+                    base_path=base_paths[name]
+                )
+            )
+
+            for sample_num, sample in enumerate(
+                itertools.islice(
+                    samples,
+                    constraint.start,
+                    constraint.stop,
+                    constraint.step
+                )
+            ):
+                normalized_sample = self.config.normalizer(sample)
+
+                if not self.config.filter(normalized_sample):
+                    continue
+
+                yield candidate.name + '_' + str(sample_num), normalized_sample
+
+            samples.close()

utils.py

@@ -0,0 +1,341 @@
+from typing import Dict, TypeVar, Callable, List, Hashable, Literal, Union, Optional, Tuple, Collection, Iterable
+from xml.etree import ElementTree
+import unicodedata
+from pathlib import Path
+import re
+
+Paths = Tuple[str, ...]
+Language = Literal['de', 'en']
+Translation = Dict[
+    Language, str
+]
+Sample = Dict[
+    Literal['translation'], Translation
+]
+SampleBatch = Dict[
+    Literal['translation'], List[Translation]
+]
+
+_H1 = TypeVar('_H1', bound=Hashable)
+_H2 = TypeVar('_H2', bound=Hashable)
+_T1 = TypeVar('_T1')
+_T2 = TypeVar('_T2')
+
+
+def dict_filter_keys(
+    input: Dict[_H1, _T1],
+    keys: List[_H1]
+) -> Dict[_H1, _T1]:
+    return dict(
+        (key, input[key])
+        for key in keys
+    )
+
+
+def dict_flatten(
+    input: Dict[_H1, Dict[_H2, _T2]]
+) -> Dict[_H2, _T2]:
+    return dict(
+        items for values in input.values()
+        for items in values.items()
+    )
+
+
+def dict_map(
+    input: Dict[_H1, _T1],
+    map_fn: Callable[[_H1, _T1], Tuple[_H2, _T2]]
+) -> Dict[_H2, _T2]:
+    return dict(
+        map_fn(key, value)
+        for key, value in input.items()
+    )
+
+
+def list_keyby(
+    input: List[_T1],
+    key_fn: Callable[[_T1], _H1]
+) -> Dict[_H1, _T1]:
+    return dict(
+        (key_fn(value), value)
+        for value in input
+    )
+
+
+def expand_path(
+    path: Path
+):
+    if path.is_file():
+        return [path]
+
+    return list(
+        path.iterdir()
+    )
+
+
+def lenif(
+    input: Collection[_T1],
+    predicate_fn: Callable[[_T1], bool]
+):
+    return sum(
+        predicate_fn(value)
+        for value in input
+    )
+
+
+def len_alpha(
+    string: str
+):
+    return lenif(
+        input=string,
+        predicate_fn=lambda character: character.isalpha()
+    )
+
+
+unicode_control_characters = (
+    r'\x00-\x1F\x7F-\x9F\xAD\u0600-\u0605\u061C\u06DD\u070F\u0890-\u0891'
+    r'\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB'
+    r'\U000110BD\U000110CD\U00013430-\U0001343F\U0001BCA0-\U0001BCA3\U0001D173-\U0001D17A'
+    r'\U000E0001\U000E0020-\U000E007F\uE000\uF8FF\U000F0000\U000FFFFD\U00100000\U0010FFFD'
+)
+
+
+def normalize(
+    strip_whitespaces: bool,
+    clean_control_characters: bool,
+    enforce_unicode_form: Optional[
+        Literal['NFC', 'NFKC', 'NFD', 'NFKD']
+    ] = None
+):
+    regex_pattern = re.compile(
+        pattern='[' + unicode_control_characters + ']+'
+    )
+
+    def normalize_fn(
+        sample: Sample
+    ):
+        translation = sample['translation']
+
+        if strip_whitespaces:
+            translation = dict_map(
+                input=translation,
+                map_fn=lambda key, value: (
+                    key, value.strip()
+                )
+            )
+
+        if clean_control_characters:
+            translation = dict_map(
+                input=translation, map_fn=lambda key, value: (
+                    key, regex_pattern.sub(
+                        repl='', string=value
+                    )
+                )
+            )
+
+        if enforce_unicode_form is not None:
+            translation = dict_map(
+                input=translation, map_fn=lambda key, value: (
+                    key, unicodedata.normalize(
+                        enforce_unicode_form, value
+                    )
+                )
+            )
+
+        sample['translation'] = translation
+        return sample
+
+    return normalize_fn
+
+
+def cleanup(
+    length_min: int,
+    length_max: int,
+    length_ratio_max: Union[int, float],
+    alpha_ratio_min: Union[int, float]
+):
+    def cleanup_fn(
+        sample: Sample
+    ):
+        translation = sample['translation']
+
+        lenghts = list(
+            len(value) for value in translation.values()
+        )
+        alpha_lengths = list(
+            len_alpha(value) for value in translation.values()
+        )
+
+        return all(
+            length_min < length < length_max and alpha_ratio_min < alpha_length / length
+            for length, alpha_length in zip(lenghts, alpha_lengths)
+        ) and 1 / length_ratio_max < lenghts[0] / lenghts[1] < length_ratio_max
+
+    return cleanup_fn
+
+
+class NoResultFound(Exception):
+    pass
+
+
+class MultipleResultsFound(Exception):
+    pass
+
+
+def one(
+    iterable: Iterable[_T1]
+) -> _T1:
+    iterator = iter(iterable)
+
+    try:
+        value = next(iterator)
+    except StopIteration as e:
+        raise NoResultFound from e
+
+    try:
+        next(iterator)
+    except StopIteration:
+        pass
+    else:
+        raise MultipleResultsFound
+
+    return value
+
+
+def match_one(
+    pattern: Union[str, re.Pattern[str]],
+    string: str,
+    flags: int = 0
+):
+    return one(
+        iterable=re.finditer(
+            pattern=pattern,
+            string=string,
+            flags=flags
+        )
+    )
+
+
+def parse_sgm(
+    filepaths: Paths,
+    files: Dict[Language, int],
+    encoding: str = 'utf-8'
+):
+    assert len(filepaths) == 2
+
+    def read_lines_regex(
+        filepath: str,
+        pattern: re.Pattern[str]
+    ):
+        with open(
+            file=filepath,
+            encoding=encoding,
+            mode='r'
+        ) as file:
+            for string in file:
+                try:
+                    match = match_one(
+                        pattern=pattern,
+                        string=string
+                    )
+                    groups = match.groups(
+                        default=''
+                    )
+                    yield groups[0]
+                except:
+                    yield ''
+
+    regex = re.compile(
+        pattern=r'<seg id="\d+">(.*)</seg>'
+    )
+
+    for lines in zip(
+        read_lines_regex(
+            filepath=filepaths[0],
+            pattern=regex
+        ),
+        read_lines_regex(
+            filepath=filepaths[1],
+            pattern=regex
+        )
+    ):
+        translation: Translation
+        translation = dict(
+            (language, lines[index])
+            for language, index in files.items()
+        )
+
+        sample: Sample = dict()
+        sample['translation'] = translation
+        yield sample
+
+
+def parse_tsv(
+    filepaths: Paths,
+    columns: Dict[Language, int],
+    encoding: str = 'utf-8'
+):
+    assert len(filepaths) == 1
+
+    len_columns = len(columns)
+
+    with open(
+        file=filepaths[0],
+        encoding=encoding,
+        mode='r'
+    ) as file:
+        for line in file:
+            parts = line.split('\t')
+
+            if len(parts) < len_columns:
+                continue
+
+            translation: Translation = dict()
+            for language, index in columns.items():
+                translation[language] = parts[index]
+
+            sample: Sample = dict()
+            sample['translation'] = translation
+            yield sample
+
+
+def parse_tmx(
+    filepaths: Paths,
+    attributes: Dict[Language, str],
+    encoding: str = 'utf-8',
+):
+    assert len(filepaths) == 1
+
+    element: ElementTree.Element
+    namespaces = {
+        'xml': 'http://www.w3.org/XML/1998/namespace'
+    }
+
+    with open(
+        file=filepaths[0],
+        encoding=encoding,
+        mode='r'
+    ) as file:
+        for _, element in ElementTree.iterparse(file):
+            if not element.tag == 'tu':
+                continue
+
+            translation: Translation = dict()
+            for language, selector in attributes.items():
+                path = 'tuv[@' + selector + ']'
+
+                segs = element.findall(
+                    path=path + '/seg', namespaces=namespaces
+                )
+                if not len(segs) == 1:
+                    continue
+
+                translation[language] = segs[0].text or ''
+
+            element.clear()
+
+            if not len(translation) == 2:
+                continue
+
+            sample: Sample = dict()
+            sample['translation'] = translation
+            yield sample