Upload oscar_2201.py with huggingface_hub

oscar_2201.py

@@ -0,0 +1,340 @@
+import re
+import gzip
+import json
+from pathlib import Path
+from typing import Dict, List, Tuple
+from urllib.parse import urljoin
+
+import datasets
+
+from seacrowd.utils import schemas
+from seacrowd.utils.configs import SEACrowdConfig
+from seacrowd.utils.constants import Tasks, Licenses
+
+_CITATION = """\
+@inproceedings{abadji2022cleaner,
+    author    = {Julien Abadji and
+                Pedro Javier Ortiz Su{\'{a}}rez and
+                Laurent Romary and
+                Beno{\^{\i}}t Sagot},
+    title     = {Towards a Cleaner Document-Oriented Multilingual Crawled Corpus},
+    booktitle = {Proceedings of the Thirteenth Language Resources and Evaluation Conference,
+                {LREC} 2022, Marseille, France, 20-25 June 2022},
+    pages     = {4344--4355},
+    publisher = {European Language Resources Association},
+    year      = {2022},
+    url       = {https://aclanthology.org/2022.lrec-1.463},
+}
+
+@inproceedings{abadji2021ungoliant,
+    author    = {Julien Abadji and
+                Pedro Javier Ortiz Su{\'a}rez and
+                Laurent Romary and
+                Beno{\^i}t Sagot},
+    title     = {Ungoliant: An optimized pipeline for the generation of a very large-scale multilingual web corpus},
+    series    = {Proceedings of the Workshop on Challenges in the Management of Large Corpora
+                (CMLC-9) 2021. Limerick, 12 July 2021 (Online-Event)},
+    editor    = {Harald L{\"u}ngen and
+                Marc Kupietz and
+                Piotr Bański and
+                Adrien Barbaresi and
+                Simon Clematide and
+                Ines Pisetta},
+    publisher = {Leibniz-Institut f{\"u}r Deutsche Sprache},
+    address   = {Mannheim},
+    doi       = {10.14618/ids-pub-10468},
+    url       = {https://nbn-resolving.org/urn:nbn:de:bsz:mh39-104688},
+    pages     = {1 -- 9},
+    year      = {2021},
+    abstract  = {Since the introduction of large language models in Natural Language
+    Processing, large raw corpora have played a crucial role in Computational Linguistics.
+    However, most of these large raw corpora are either available only for English or not
+    available to the general public due to copyright issues. Nevertheless, there are some
+    examples of freely available multilingual corpora for training Deep Learning NLP
+    models, such as the OSCAR and Paracrawl corpora. However, they have quality issues,
+    especially for low-resource languages. Moreover, recreating or updating these corpora
+    is very complex. In this work, we try to reproduce and improve the goclassy pipeline
+    used to create the OSCAR corpus. We propose a new pipeline that is faster, modular,
+    parameterizable, and well documented. We use it to create a corpus similar to OSCAR
+    but larger and based on recent data. Also, unlike OSCAR, the metadata information is
+    at the document level. We release our pipeline under an open source license and
+    publish the corpus under a research-only license.},
+    language  = {en}
+}
+
+@article{kreutzer2022quality,
+    title     = {Quality at a Glance: An Audit of Web-Crawled Multilingual Datasets},
+    author    = {Kreutzer, Julia  and
+                Caswell, Isaac  and
+                Wang, Lisa  and
+                Wahab, Ahsan  and
+                van Esch, Daan  and
+                Ulzii-Orshikh, Nasanbayar  and
+                Tapo, Allahsera  and
+                Subramani, Nishant  and
+                Sokolov, Artem  and
+                Sikasote, Claytone  and
+                Setyawan, Monang  and
+                Sarin, Supheakmungkol  and
+                Samb, Sokhar  and
+                Sagot, Beno{\^\i}t  and
+                Rivera, Clara  and
+                Rios, Annette  and
+                Papadimitriou, Isabel  and
+                Osei, Salomey  and
+                Suarez, Pedro Ortiz  and
+                Orife, Iroro  and
+                Ogueji, Kelechi  and
+                Rubungo, Andre Niyongabo  and
+                Nguyen, Toan Q.  and
+                M{\"u}ller, Mathias  and
+                M{\"u}ller, Andr{\'e}  and
+                Muhammad, Shamsuddeen Hassan  and
+                Muhammad, Nanda  and
+                Mnyakeni, Ayanda  and
+                Mirzakhalov, Jamshidbek  and
+                Matangira, Tapiwanashe  and
+                Leong, Colin  and
+                Lawson, Nze  and
+                Kudugunta, Sneha  and
+                Jernite, Yacine  and
+                Jenny, Mathias  and
+                Firat, Orhan  and
+                Dossou, Bonaventure F. P.  and
+                Dlamini, Sakhile  and
+                de Silva, Nisansa  and
+                {\c{C}}abuk Ball{\i}, Sakine  and
+                Biderman, Stella  and
+                Battisti, Alessia  and
+                Baruwa, Ahmed  and
+                Bapna, Ankur  and
+                Baljekar, Pallavi  and
+                Azime, Israel Abebe  and
+                Awokoya, Ayodele  and
+                Ataman, Duygu  and
+                Ahia, Orevaoghene  and
+                Ahia, Oghenefego  and
+                Agrawal, Sweta  and
+                Adeyemi, Mofetoluwa},
+    editor    = {Roark, Brian  and
+                Nenkova, Ani},
+    journal   = {Transactions of the Association for Computational Linguistics},
+    volume    = {10},
+    year      = {2022},
+    address   = {Cambridge, MA},
+    publisher = {MIT Press},
+    url       = {https://aclanthology.org/2022.tacl-1.4},
+    doi       = {10.1162/tacl_a_00447},
+    pages     = {50--72},
+    abstract  = {With the success of large-scale pre-training and multilingual modeling in
+    Natural Language Processing (NLP), recent years have seen a proliferation of large,
+    Web-mined text datasets covering hundreds of languages. We manually audit the quality
+    of 205 language-specific corpora released with five major public datasets (CCAligned,
+    ParaCrawl, WikiMatrix, OSCAR, mC4). Lower-resource corpora have systematic issues: At
+    least 15 corpora have no usable text, and a significant fraction contains less than
+    50{\%} sentences of acceptable quality. In addition, many are mislabeled or use
+    nonstandard/ambiguous language codes. We demonstrate that these issues are easy to
+    detect even for non-proficient speakers, and supplement the human audit with automatic
+    analyses. Finally, we recommend techniques to evaluate and improve multilingual
+    corpora and discuss potential risks that come with low-quality data releases.},
+}
+
+@inproceedings{ortizsuarez2020monolingual,
+    title     = {A Monolingual Approach to Contextualized Word Embeddings for Mid-Resource Languages},
+    author    = {Ortiz Su{'a}rez, Pedro Javier  and
+                Romary, Laurent  and
+                Sagot, Benoit},
+    booktitle = {Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics},
+    month     = {jul},
+    year      = {2020},
+    address   = {Online},
+    publisher = {Association for Computational Linguistics},
+    url       = {https://www.aclweb.org/anthology/2020.acl-main.156},
+    pages     = {1703--1714},
+    abstract  = {We use the multilingual OSCAR corpus, extracted from Common Crawl via
+    language classification, filtering and cleaning, to train monolingual contextualized
+    word embeddings (ELMo) for five mid-resource languages. We then compare the
+    performance of OSCAR-based and Wikipedia-based ELMo embeddings for these languages on
+    the part-of-speech tagging and parsing tasks. We show that, despite the noise in the
+    Common-Crawl-based OSCAR data, embeddings trained on OSCAR perform much better than
+    monolingual embeddings trained on Wikipedia. They actually equal or improve the
+    current state of the art in tagging and parsing for all five languages. In particular,
+    they also improve over multilingual Wikipedia-based contextual embeddings
+    (multilingual BERT), which almost always constitutes the previous state of the art,
+    thereby showing that the benefit of a larger, more diverse corpus surpasses the
+    cross-lingual benefit of multilingual embedding architectures.},
+}
+
+@inproceedings{ortizsuarez2019asynchronous,
+    author    = {Pedro Javier {Ortiz Su{'a}rez} and
+                Benoit Sagot and
+                Laurent Romary},
+    title     = {Asynchronous pipelines for processing huge corpora on medium to low resource infrastructures},
+    series    = {Proceedings of the Workshop on Challenges in the Management of Large Corpora
+                (CMLC-7) 2019. Cardiff, 22nd July 2019},
+    editor    = {Piotr Bański and
+                Adrien Barbaresi and
+                Hanno Biber and
+                Evelyn Breiteneder and
+                Simon Clematide and
+                Marc Kupietz and
+                Harald L{"u}ngen and
+                Caroline Iliadi},
+    publisher = {Leibniz-Institut f{"u}r Deutsche Sprache},
+    address   = {Mannheim},
+    doi       = {10.14618/ids-pub-9021},
+    url       = {http://nbn-resolving.de/urn:nbn:de:bsz:mh39-90215},
+    pages     = {9 -- 16},
+    year      = {2019},
+    abstract  = {Common Crawl is a considerably large, heterogeneous multilingual corpus
+    comprised of crawled documents from the internet, surpassing 20TB of data and
+    distributed as a set of more than 50 thousand plain text files where each contains
+    many documents written in a wide variety of languages. Even though each document has a
+    metadata block associated to it, this data lacks any information about the language in
+    which each document is written, making it extremely difficult to use Common Crawl for
+    monolingual applications. We propose a general, highly parallel, multithreaded
+    pipeline to clean and classify Common Crawl by language; we specifically design it so
+    that it runs efficiently on medium to low resource infrastructures where I/O speeds
+    are the main constraint. We develop the pipeline so that it can be easily reapplied to
+    any kind of heterogeneous corpus and so that it can be parameterised to a wide range
+    of infrastructures. We also distribute a 6.3TB version of Common Crawl, filtered,
+    classified by language, shuffled at line level in order to avoid copyright issues, and
+    ready to be used for NLP applications.},
+    language  = {en}
+}
+"""
+
+_DATASETNAME = "oscar_2201"
+_DESCRIPTION = """\
+OSCAR or Open Super-large Crawled Aggregated coRpus is a huge multilingual corpus
+obtained by language classification and filtering of the Common Crawl corpus using
+the ungoliant architecture. Data is distributed by language in both original and
+deduplicated form.
+"""
+
+_HOMEPAGE = "https://huggingface.co/datasets/oscar-corpus/OSCAR-2201"
+_LICENSE = Licenses.CC0_1_0.value
+_BASE_URL = "https://huggingface.co/datasets/oscar-corpus/OSCAR-2201/resolve/main/compressed/{lang}_meta/"
+
+_LOCAL = False
+_LANGUAGES = ["war", "ceb", "min", "vie", "ilo", "tgl", "lao", "khm", "mya", "jav", "ind", "tha", "sun", "zlm"]
+
+_SUPPORTED_TASKS = [Tasks.SELF_SUPERVISED_PRETRAINING]
+_SOURCE_VERSION = "2022.1.0"
+_SEACROWD_VERSION = "2024.06.20"
+
+
+class Oscar2201Dataset(datasets.GeneratorBasedBuilder):
+    """OSCAR subset for SEA languages, version 2201."""
+
+    SOURCE_VERSION = datasets.Version(_SOURCE_VERSION)
+    SEACROWD_VERSION = datasets.Version(_SEACROWD_VERSION)
+
+    SEACROWD_SCHEMA_NAME = "ssp"
+    SUBSETS = ["war", "ceb", "min", "vi", "ta", "ilo", "tl", "lo", "km", "my", "jv", "id", "th", "su", "ms"]
+
+    BUILDER_CONFIGS = [
+        SEACrowdConfig(
+            name=f"{_DATASETNAME}_{subset}_source",
+            version=datasets.Version(_SOURCE_VERSION),
+            description=f"{_DATASETNAME} {subset} source schema",
+            schema="source",
+            subset_id=subset,
+        ) for subset in SUBSETS
+    ] + [
+        SEACrowdConfig(
+            name=f"{_DATASETNAME}_{subset}_seacrowd_ssp",
+            version=datasets.Version(_SEACROWD_VERSION),
+            description=f"{_DATASETNAME} {subset} SEACrowd schema",
+            schema="seacrowd_ssp",
+            subset_id=subset,
+        )
+        for subset in SUBSETS
+    ]
+
+    DEFAULT_CONFIG_NAME = f"{_DATASETNAME}_jv_source"
+
+    def _info(self) -> datasets.DatasetInfo:
+        if self.config.schema == "source":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("int64"),
+                    "text": datasets.Value("string"),
+                    "meta": {
+                        "warc_headers": {
+                            "warc-record-id": datasets.Value("string"),
+                            "warc-date": datasets.Value("string"),
+                            "content-type": datasets.Value("string"),
+                            "content-length": datasets.Value("int32"),
+                            "warc-type": datasets.Value("string"),
+                            "warc-identified-content-language": datasets.Value("string"),
+                            "warc-refers-to": datasets.Value("string"),
+                            "warc-target-uri": datasets.Value("string"),
+                            "warc-block-digest": datasets.Value("string"),
+                        },
+                        "identification": {
+                            "label": datasets.Value("string"),
+                            "prob": datasets.Value("float"),
+                        },
+                        "annotations": datasets.Sequence(datasets.Value("string")),
+                        "line_identifications": [
+                            {
+                                "label": datasets.Value("string"),
+                                "prob": datasets.Value("float"),
+                            }
+                        ],
+                    },
+                }
+            )
+        elif self.config.schema == f"seacrowd_{self.SEACROWD_SCHEMA_NAME}":
+            features = schemas.ssp_features
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager: datasets.DownloadManager) -> List[datasets.SplitGenerator]:
+        """Returns SplitGenerators."""
+        base_path = _BASE_URL.format(lang=self.config.name.split("_")[2])
+
+        checksum_url = urljoin(base_path, "checksum.sha256")
+        checksum_path = Path(dl_manager.download(checksum_url))
+        with open(checksum_path, encoding="utf-8") as f:
+            filenames = [line.split()[1] for line in f if line]
+            filenames = sorted(filenames, key=lambda x: int(re.search(r"\d+", x).group()) if re.search(r"\d+", x) else x)
+            data_urls = [urljoin(base_path, filename) for filename in filenames]
+
+        data_paths = list(map(Path, dl_manager.download([url for url in data_urls if url.endswith(".jsonl.gz")])))
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "filepaths": data_paths,
+                    "split": "train",
+                },
+            )
+        ]
+
+    def _generate_examples(self, filepaths: [Path], split: str) -> Tuple[int, Dict]:
+        """Yields examples as (key, example) tuples."""
+        key = 0
+        for filepath in filepaths:
+            with gzip.open(open(filepath, "rb"), "rt", encoding="utf-8") as f:
+                for line in f:
+                    doc = json.loads(line)
+                    if self.config.schema == "source":
+                        meta = dict()
+                        meta["warc_headers"] = doc["warc_headers"]
+                        meta["warc_headers"]["warc-identified-content-language"] = doc["warc_headers"].get("warc-identified-content-language")
+                        meta["identification"] = doc["metadata"]["identification"]
+                        meta["annotations"] = doc["metadata"]["annotation"]
+                        meta["line_identifications"] = doc["metadata"]["sentence_identifications"]
+                        yield key, {"id": key, "text": doc["content"], "meta": meta}
+                    elif self.config.schema == f"seacrowd_{self.SEACROWD_SCHEMA_NAME}":
+                        yield key, {"id": str(key), "text": doc["content"]}
+                    key += 1