add fleurs dataset with text normaliser for indonesian

README.md

@@ -1,3 +1,310 @@
 ---
-license: mit
+annotations_creators:
+- expert-generated
+- crowdsourced
+- machine-generated
+language_creators:
+- crowdsourced
+- expert-generated
+language:
+- afr
+- amh
+- ara
+- asm
+- ast
+- azj
+- bel
+- ben
+- bos
+- cat
+- ceb
+- cmn
+- ces
+- cym
+- dan
+- deu
+- ell
+- eng
+- spa
+- est
+- fas
+- ful
+- fin
+- tgl
+- fra
+- gle
+- glg
+- guj
+- hau
+- heb
+- hin
+- hrv
+- hun
+- hye
+- ind
+- ibo
+- isl
+- ita
+- jpn
+- jav
+- kat
+- kam
+- kea
+- kaz
+- khm
+- kan
+- kor
+- ckb
+- kir
+- ltz
+- lug
+- lin
+- lao
+- lit
+- luo
+- lav
+- mri
+- mkd
+- mal
+- mon
+- mar
+- msa
+- mlt
+- mya
+- nob
+- npi
+- nld
+- nso
+- nya
+- oci
+- orm
+- ory
+- pan
+- pol
+- pus
+- por
+- ron
+- rus
+- bul
+- snd
+- slk
+- slv
+- sna
+- som
+- srp
+- swe
+- swh
+- tam
+- tel
+- tgk
+- tha
+- tur
+- ukr
+- umb
+- urd
+- uzb
+- vie
+- wol
+- xho
+- yor
+- yue
+- zul
+license:
+- cc-by-4.0
+multilinguality:
+- multilingual
+size_categories:
+- 10K<n<100K
+task_categories:
+- automatic-speech-recognition
+task_ids: []
+pretty_name: 'The Cross-lingual TRansfer Evaluation of Multilingual Encoders for Speech
+  (XTREME-S) benchmark is a benchmark designed to evaluate speech representations
+  across languages, tasks, domains and data regimes. It covers 102 languages from
+  10+ language families, 3 different domains and 4 task families: speech recognition,
+  translation, classification and retrieval.'
+tags:
+- speech-recognition
 ---
+
+# FLEURS
+
+## Dataset Description
+
+- **Fine-Tuning script:** [pytorch/speech-recognition](https://github.com/huggingface/transformers/tree/main/examples/pytorch/speech-recognition)
+- **Paper:** [FLEURS: Few-shot Learning Evaluation of
+Universal Representations of Speech](https://arxiv.org/abs/2205.12446)
+- **Total amount of disk used:** ca. 350 GB
+
+Fleurs is the speech version of the [FLoRes machine translation benchmark](https://arxiv.org/abs/2106.03193). 
+We use 2009 n-way parallel sentences from the FLoRes dev and devtest publicly available sets, in 102 languages. 
+
+Training sets have around 10 hours of supervision. Speakers of the train sets are different than speakers from the dev/test sets. Multilingual fine-tuning is
+used and ”unit error rate” (characters, signs) of all languages is averaged. Languages and results are also grouped into seven geographical areas: 
+
+- **Western Europe**: *Asturian, Bosnian, Catalan, Croatian, Danish, Dutch, English, Finnish, French, Galician, German, Greek, Hungarian, Icelandic, Irish, Italian, Kabuverdianu, Luxembourgish, Maltese, Norwegian, Occitan, Portuguese, Spanish, Swedish, Welsh* 
+- **Eastern Europe**: *Armenian, Belarusian, Bulgarian, Czech, Estonian, Georgian, Latvian, Lithuanian, Macedonian, Polish, Romanian, Russian, Serbian, Slovak, Slovenian, Ukrainian*
+- **Central-Asia/Middle-East/North-Africa**: *Arabic, Azerbaijani, Hebrew, Kazakh, Kyrgyz, Mongolian, Pashto, Persian, Sorani-Kurdish, Tajik, Turkish, Uzbek*
+- **Sub-Saharan Africa**: *Afrikaans, Amharic, Fula, Ganda, Hausa, Igbo, Kamba, Lingala, Luo, Northern-Sotho, Nyanja, Oromo, Shona, Somali, Swahili, Umbundu, Wolof, Xhosa, Yoruba, Zulu*
+- **South-Asia**: *Assamese, Bengali, Gujarati, Hindi, Kannada, Malayalam, Marathi, Nepali, Oriya, Punjabi, Sindhi, Tamil, Telugu, Urdu*
+- **South-East Asia**: *Burmese, Cebuano, Filipino, Indonesian, Javanese, Khmer, Lao, Malay, Maori, Thai, Vietnamese*
+- **CJK languages**: *Cantonese and Mandarin Chinese, Japanese, Korean*
+
+
+## Supported Tasks
+
+### 1. Speech Recognition (ASR)
+
+```py
+from datasets import load_dataset
+
+fleurs_asr = load_dataset("google/fleurs", "af_za")  # for Afrikaans
+# to download all data for multi-lingual fine-tuning uncomment following line
+# fleurs_asr = load_dataset("google/fleurs", "all")
+
+# see structure
+print(fleurs_asr)
+
+# load audio sample on the fly
+audio_input = fleurs_asr["train"][0]["audio"]  # first decoded audio sample
+transcription = fleurs_asr["train"][0]["transcription"]  # first transcription
+# use `audio_input` and `transcription` to fine-tune your model for ASR
+
+# for analyses see language groups
+all_language_groups = fleurs_asr["train"].features["lang_group_id"].names
+lang_group_id = fleurs_asr["train"][0]["lang_group_id"]
+
+all_language_groups[lang_group_id]
+```
+
+### 2. Language Identification
+
+LangID can often be a domain classification, but in the case of FLEURS-LangID, recordings are done in a similar setting across languages and the utterances correspond to n-way parallel sentences, in the exact same domain, making this task particularly relevant for evaluating LangID. The setting is simple, FLEURS-LangID is splitted in train/valid/test for each language. We simply create a single train/valid/test for LangID by merging all.
+
+```py
+from datasets import load_dataset
+
+fleurs_langID = load_dataset("google/fleurs", "all") # to download all data
+
+# see structure
+print(fleurs_langID)
+
+# load audio sample on the fly
+audio_input = fleurs_langID["train"][0]["audio"]  # first decoded audio sample
+language_class = fleurs_langID["train"][0]["lang_id"]  # first id class
+language = fleurs_langID["train"].features["lang_id"].names[language_class]
+
+# use audio_input and language_class to fine-tune your model for audio classification
+```
+
+### 3. Retrieval
+
+Retrieval provides n-way parallel speech and text data. Similar to how XTREME for text leverages Tatoeba to evaluate bitext mining a.k.a sentence translation retrieval, we use Retrieval to evaluate the quality of fixed-size representations of speech utterances. Our goal is to incentivize the creation of fixed-size speech encoder for speech retrieval. The system has to retrieve the English "key" utterance corresponding to the speech translation of "queries" in 15 languages. Results have to be reported on the test sets of Retrieval whose utterances are used as queries (and keys for English). We augment the English keys with a large number of utterances to make the task more difficult.
+
+```py
+from datasets import load_dataset
+
+fleurs_retrieval = load_dataset("google/fleurs", "af_za")  # for Afrikaans
+# to download all data for multi-lingual fine-tuning uncomment following line
+# fleurs_retrieval = load_dataset("google/fleurs", "all")
+
+# see structure
+print(fleurs_retrieval)
+
+# load audio sample on the fly
+audio_input = fleurs_retrieval["train"][0]["audio"]  # decoded audio sample
+text_sample_pos = fleurs_retrieval["train"][0]["transcription"]  # positive text sample
+text_sample_neg = fleurs_retrieval["train"][1:20]["transcription"] # negative text samples
+
+# use `audio_input`, `text_sample_pos`, and `text_sample_neg` to fine-tune your model for retrieval
+```
+
+Users can leverage the training (and dev) sets of FLEURS-Retrieval with a ranking loss to build better cross-lingual fixed-size representations of speech.
+
+## Dataset Structure
+
+We show detailed information the example configurations `af_za` of the dataset.
+All other configurations have the same structure.
+
+### Data Instances
+
+**af_za**
+- Size of downloaded dataset files: 1.47 GB
+- Size of the generated dataset: 1 MB
+- Total amount of disk used: 1.47 GB
+
+An example of a data instance of the config `af_za` looks as follows:
+
+```
+{'id': 91,
+ 'num_samples': 385920,
+ 'path': '/home/patrick/.cache/huggingface/datasets/downloads/extracted/310a663d52322700b3d3473cbc5af429bd92a23f9bc683594e70bc31232db39e/home/vaxelrod/FLEURS/oss2_obfuscated/af_za/audio/train/17797742076841560615.wav',
+ 'audio': {'path': '/home/patrick/.cache/huggingface/datasets/downloads/extracted/310a663d52322700b3d3473cbc5af429bd92a23f9bc683594e70bc31232db39e/home/vaxelrod/FLEURS/oss2_obfuscated/af_za/audio/train/17797742076841560615.wav',
+  'array': array([ 0.0000000e+00,  0.0000000e+00,  0.0000000e+00, ...,
+         -1.1205673e-04, -8.4638596e-05, -1.2731552e-04], dtype=float32),
+  'sampling_rate': 16000},
+ 'raw_transcription': 'Dit is nog nie huidiglik bekend watter aantygings gemaak sal word of wat owerhede na die seun gelei het nie maar jeugmisdaad-verrigtinge het in die federale hof begin',
+ 'transcription': 'dit is nog nie huidiglik bekend watter aantygings gemaak sal word of wat owerhede na die seun gelei het nie maar jeugmisdaad-verrigtinge het in die federale hof begin',
+ 'gender': 0,
+ 'lang_id': 0,
+ 'language': 'Afrikaans',
+ 'lang_group_id': 3}
+```
+
+### Data Fields
+
+The data fields are the same among all splits.
+- **id** (int): ID of audio sample
+- **num_samples** (int): Number of float values
+- **path** (str): Path to the audio file
+- **audio** (dict): Audio object including loaded audio array, sampling rate and path ot audio
+- **raw_transcription** (str): The non-normalized transcription of the audio file
+- **transcription** (str): Transcription of the audio file
+- **gender** (int): Class id of gender
+- **lang_id** (int): Class id of language
+- **lang_group_id** (int): Class id of language group
+
+### Data Splits
+
+Every config only has the `"train"` split containing of *ca.* 1000 examples, and a `"validation"` and `"test"` split each containing of *ca.* 400 examples.
+
+## Dataset Creation
+
+We collect between one and three recordings for each sentence (2.3 on average), and buildnew train-dev-test splits with 1509, 150 and 350 sentences for
+train, dev and test respectively.
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+This dataset is meant to encourage the development of speech technology in a lot more languages of the world. One of the goal is to give equal access to technologies like speech recognition or speech translation to everyone, meaning better dubbing or better access to content from the internet (like podcasts, streaming or videos).
+
+### Discussion of Biases
+
+Most datasets have a fair distribution of gender utterances (e.g. the newly introduced FLEURS dataset). While many languages are covered from various regions of the world, the benchmark misses many languages that are all equally important. We believe technology built through FLEURS should generalize to all languages.
+
+### Other Known Limitations
+
+The dataset has a particular focus on read-speech because common evaluation benchmarks like CoVoST-2 or LibriSpeech evaluate on this type of speech. There is sometimes a known mismatch between performance obtained in a read-speech setting and a more noisy setting (in production for instance). Given the big progress that remains to be made on many languages, we believe better performance on FLEURS should still correlate well with actual progress made for speech understanding.
+
+## Additional Information
+
+All datasets are licensed under the [Creative Commons license (CC-BY)](https://creativecommons.org/licenses/).
+
+### Citation Information
+
+You can access the FLEURS paper at https://arxiv.org/abs/2205.12446.
+Please cite the paper when referencing the FLEURS corpus as:
+
+```
+@article{fleurs2022arxiv,
+  title = {FLEURS: Few-shot Learning Evaluation of Universal Representations of Speech},
+  author = {Conneau, Alexis and Ma, Min and Khanuja, Simran and Zhang, Yu and Axelrod, Vera and Dalmia, Siddharth and Riesa, Jason and Rivera, Clara and Bapna, Ankur},
+  journal={arXiv preprint arXiv:2205.12446},
+  url = {https://arxiv.org/abs/2205.12446},
+  year = {2022},
+```
+
+### Contributions
+
+Thanks to [@patrickvonplaten](https://github.com/patrickvonplaten) and [@aconneau](https://github.com/aconneau) for adding this dataset.

data/metadata.zip

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

fleurs.py

@@ -0,0 +1,246 @@
+# coding=utf-8
+# Copyright 2022 The Google and 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.
+
+import os
+from collections import OrderedDict
+from text_processor.text_processor import TextProcessor
+import datasets
+
+logger = datasets.logging.get_logger(__name__)
+
+
+""" FLEURS Dataset"""
+
+_FLEURS_LANG_TO_ID = OrderedDict([("Afrikaans", "af"), ("Amharic", "am"), ("Arabic", "ar"), ("Armenian", "hy"), ("Assamese", "as"), ("Asturian", "ast"), ("Azerbaijani", "az"), ("Belarusian", "be"), ("Bengali", "bn"), ("Bosnian", "bs"), ("Bulgarian", "bg"), ("Burmese", "my"), ("Catalan", "ca"), ("Cebuano", "ceb"), ("Mandarin Chinese", "cmn_hans"), ("Cantonese Chinese", "yue_hant"), ("Croatian", "hr"), ("Czech", "cs"), ("Danish", "da"), ("Dutch", "nl"), ("English", "en"), ("Estonian", "et"), ("Filipino", "fil"), ("Finnish", "fi"), ("French", "fr"), ("Fula", "ff"), ("Galician", "gl"), ("Ganda", "lg"), ("Georgian", "ka"), ("German", "de"), ("Greek", "el"), ("Gujarati", "gu"), ("Hausa", "ha"), ("Hebrew", "he"), ("Hindi", "hi"), ("Hungarian", "hu"), ("Icelandic", "is"), ("Igbo", "ig"), ("Indonesian", "id"), ("Irish", "ga"), ("Italian", "it"), ("Japanese", "ja"), ("Javanese", "jv"), ("Kabuverdianu", "kea"), ("Kamba", "kam"), ("Kannada", "kn"), ("Kazakh", "kk"), ("Khmer", "km"), ("Korean", "ko"), ("Kyrgyz", "ky"), ("Lao", "lo"), ("Latvian", "lv"), ("Lingala", "ln"), ("Lithuanian", "lt"), ("Luo", "luo"), ("Luxembourgish", "lb"), ("Macedonian", "mk"), ("Malay", "ms"), ("Malayalam", "ml"), ("Maltese", "mt"), ("Maori", "mi"), ("Marathi", "mr"), ("Mongolian", "mn"), ("Nepali", "ne"), ("Northern-Sotho", "nso"), ("Norwegian", "nb"), ("Nyanja", "ny"), ("Occitan", "oc"), ("Oriya", "or"), ("Oromo", "om"), ("Pashto", "ps"), ("Persian", "fa"), ("Polish", "pl"), ("Portuguese", "pt"), ("Punjabi", "pa"), ("Romanian", "ro"), ("Russian", "ru"), ("Serbian", "sr"), ("Shona", "sn"), ("Sindhi", "sd"), ("Slovak", "sk"), ("Slovenian", "sl"), ("Somali", "so"), ("Sorani-Kurdish", "ckb"), ("Spanish", "es"), ("Swahili", "sw"), ("Swedish", "sv"), ("Tajik", "tg"), ("Tamil", "ta"), ("Telugu", "te"), ("Thai", "th"), ("Turkish", "tr"), ("Ukrainian", "uk"), ("Umbundu", "umb"), ("Urdu", "ur"), ("Uzbek", "uz"), ("Vietnamese", "vi"), ("Welsh", "cy"), ("Wolof", "wo"), ("Xhosa", "xh"), ("Yoruba", "yo"), ("Zulu", "zu")])
+_FLEURS_LANG_SHORT_TO_LONG = {v: k for k, v in _FLEURS_LANG_TO_ID.items()}
+
+
+_FLEURS_LANG = sorted(["af_za", "am_et", "ar_eg", "as_in", "ast_es", "az_az", "be_by", "bn_in", "bs_ba", "ca_es", "ceb_ph", "cmn_hans_cn", "yue_hant_hk", "cs_cz", "cy_gb", "da_dk", "de_de", "el_gr", "en_us", "es_419", "et_ee", "fa_ir", "ff_sn", "fi_fi", "fil_ph", "fr_fr", "ga_ie", "gl_es", "gu_in", "ha_ng", "he_il", "hi_in", "hr_hr", "hu_hu", "hy_am", "id_id", "ig_ng", "is_is", "it_it", "ja_jp", "jv_id", "ka_ge", "kam_ke", "kea_cv", "kk_kz", "km_kh", "kn_in", "ko_kr", "ckb_iq", "ky_kg", "lb_lu", "lg_ug", "ln_cd", "lo_la", "lt_lt", "luo_ke", "lv_lv", "mi_nz", "mk_mk", "ml_in", "mn_mn", "mr_in", "ms_my", "mt_mt", "my_mm", "nb_no", "ne_np", "nl_nl", "nso_za", "ny_mw", "oc_fr", "om_et", "or_in", "pa_in", "pl_pl", "ps_af", "pt_br", "ro_ro", "ru_ru", "bg_bg", "sd_in", "sk_sk", "sl_si", "sn_zw", "so_so", "sr_rs", "sv_se", "sw_ke", "ta_in", "te_in", "tg_tj", "th_th", "tr_tr", "uk_ua", "umb_ao", "ur_pk", "uz_uz", "vi_vn", "wo_sn", "xh_za", "yo_ng", "zu_za"])
+_FLEURS_LONG_TO_LANG = {_FLEURS_LANG_SHORT_TO_LONG["_".join(k.split("_")[:-1]) or k]: k for k in _FLEURS_LANG}
+_FLEURS_LANG_TO_LONG = {v: k for k, v in _FLEURS_LONG_TO_LANG.items()}
+
+_FLEURS_GROUP_TO_LONG = OrderedDict({
+    "western_european_we": ["Asturian", "Bosnian", "Catalan", "Croatian", "Danish", "Dutch", "English", "Finnish", "French", "Galician", "German", "Greek", "Hungarian", "Icelandic", "Irish", "Italian", "Kabuverdianu", "Luxembourgish", "Maltese", "Norwegian", "Occitan", "Portuguese", "Spanish", "Swedish", "Welsh"],
+    "eastern_european_ee": ["Armenian", "Belarusian", "Bulgarian", "Czech", "Estonian", "Georgian", "Latvian", "Lithuanian", "Macedonian", "Polish", "Romanian", "Russian", "Serbian", "Slovak", "Slovenian", "Ukrainian"],
+    "central_asia_middle_north_african_cmn": ["Arabic", "Azerbaijani", "Hebrew", "Kazakh", "Kyrgyz", "Mongolian", "Pashto", "Persian", "Sorani-Kurdish", "Tajik", "Turkish", "Uzbek"],
+    "sub_saharan_african_ssa": ["Afrikaans", "Amharic", "Fula", "Ganda", "Hausa", "Igbo", "Kamba", "Lingala", "Luo", "Northern-Sotho", "Nyanja", "Oromo", "Shona", "Somali", "Swahili", "Umbundu", "Wolof", "Xhosa", "Yoruba", "Zulu"],
+    "south_asian_sa": ["Assamese", "Bengali", "Gujarati", "Hindi", "Kannada", "Malayalam", "Marathi", "Nepali", "Oriya", "Punjabi", "Sindhi", "Tamil", "Telugu", "Urdu"],
+    "south_east_asian_sea": ["Burmese", "Cebuano", "Filipino", "Indonesian", "Javanese", "Khmer", "Lao", "Malay", "Maori", "Thai", "Vietnamese"],
+    "chinese_japanase_korean_cjk": ["Mandarin Chinese", "Cantonese Chinese", "Japanese", "Korean"],
+})
+_FLEURS_LONG_TO_GROUP = {a: k for k, v in _FLEURS_GROUP_TO_LONG.items() for a in v}
+_FLEURS_LANG_TO_GROUP = {_FLEURS_LONG_TO_LANG[k]: v for k, v in _FLEURS_LONG_TO_GROUP.items()}
+
+_ALL_LANG = _FLEURS_LANG
+_ALL_CONFIGS = []
+
+for langs in _FLEURS_LANG:
+    _ALL_CONFIGS.append(langs)
+
+_ALL_CONFIGS.append("all")
+
+# TODO(FLEURS)
+_DESCRIPTION = "FLEURS is the speech version of the FLORES machine translation benchmark, covering 2000 n-way parallel sentences in n=102 languages."
+_CITATION = ""
+_HOMEPAGE_URL = ""
+
+_DATA_URL = "https://storage.googleapis.com/xtreme_translations/FLEURS102/{}.tar.gz"
+_METADATA_URL = "data/metadata.zip"
+
+
+class FleursConfig(datasets.BuilderConfig):
+    """BuilderConfig for xtreme-s"""
+
+    def __init__(
+        self, name, description, citation, homepage, data_url
+    ):
+        super(FleursConfig, self).__init__(
+            name=self.name,
+            version=datasets.Version("2.0.0", ""),
+            description=self.description,
+        )
+        self.name = name
+        self.description = description
+        self.citation = citation
+        self.homepage = homepage
+        self.data_url = data_url
+
+
+def _build_config(name):
+    return FleursConfig(
+        name=name,
+        description=_DESCRIPTION,
+        citation=_CITATION,
+        homepage=_HOMEPAGE_URL,
+        data_url=_DATA_URL,
+    )
+
+
+class Fleurs(datasets.GeneratorBasedBuilder):
+
+    DEFAULT_WRITER_BATCH_SIZE = 1000
+    BUILDER_CONFIGS = [_build_config(name) for name in _ALL_CONFIGS]
+
+    def _info(self):
+        task_templates = None
+        langs = _ALL_CONFIGS
+        features = datasets.Features(
+            {
+                "id": datasets.Value("int32"),
+                "num_samples": datasets.Value("int32"),
+                "path": datasets.Value("string"),
+                "audio": datasets.Audio(sampling_rate=16_000),
+                "transcription": datasets.Value("string"),
+                "raw_transcription": datasets.Value("string"),
+                "gender": datasets.ClassLabel(names=["male", "female", "other"]),
+                "lang_id": datasets.ClassLabel(names=langs),
+                "language": datasets.Value("string"),
+                "lang_group_id": datasets.ClassLabel(
+                    names=list(_FLEURS_GROUP_TO_LONG.keys())
+                ),
+            }
+        )
+
+        return datasets.DatasetInfo(
+            description=self.config.description + "\n" + _DESCRIPTION,
+            features=features,
+            supervised_keys=("audio", "transcription"),
+            homepage=self.config.homepage,
+            citation=self.config.citation + "\n" + _CITATION,
+            task_templates=task_templates,
+        )
+
+    # Fleurs
+    def _split_generators(self, dl_manager):
+        data_url_format = self.config.data_url
+
+        metadata_path = dl_manager.download_and_extract(_METADATA_URL)
+
+        if self.config.name == "all":
+            data_urls = {l: data_url_format.format(l) for l in _FLEURS_LANG}
+        else:
+            data_urls = {
+                self.config.name: data_url_format.format(self.config.name)
+            }
+
+        archive_path = dl_manager.download(data_urls)
+        local_extracted_archive = dl_manager.extract(archive_path) if not dl_manager.is_streaming else None
+
+        archive_iters = {l: dl_manager.iter_archive(v) for l,v in archive_path.items()}
+
+        audio_path = {l: os.path.join(l, "audio") for l in archive_path.keys()}
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "local_extracted_archive": local_extracted_archive,
+                    "archive_iters": archive_iters,
+                    "audio_path": {
+                        l: os.path.join(v, "train") for l, v in audio_path.items()
+                    },
+                    "text_path": {
+                        l: os.path.join(metadata_path, "metadata", l, "train.tsv") for l in archive_path.keys()
+                    },
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={
+                    "local_extracted_archive": local_extracted_archive,
+                    "archive_iters": archive_iters,
+                    "audio_path": {
+                        l: os.path.join(v, "dev") for l, v in audio_path.items()
+                    },
+                    "text_path": {
+                        l: os.path.join(metadata_path, "metadata", l, "dev.tsv") for l in archive_path.keys()
+                    },
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "local_extracted_archive": local_extracted_archive,
+                    "archive_iters": archive_iters,
+                    "audio_path": {
+                        l: os.path.join(v, "test") for l, v in audio_path.items()
+                    },
+                    "text_path": {
+                        l: os.path.join(metadata_path, "metadata", l, "test.tsv") for l in archive_path.keys()
+                    },
+                },
+            ),
+        ]
+
+    def _get_data(self, lines, lang_id):
+        tp = TextProcessor()
+        data = {}
+        gender_to_id = {"MALE": 0, "FEMALE": 1, "OTHER": 2}
+        for line in lines:
+            if isinstance(line, bytes):
+                line = line.decode("utf-8")
+            (
+                _id,
+                file_name,
+                raw_transcription,
+                transcription,
+                _,
+                num_samples,
+                gender,
+            ) = line.strip().split("\t")
+
+            lang_group = _FLEURS_LANG_TO_GROUP[lang_id]
+            raw_transcription = tp.normalize(raw_transcription)
+            transcription = tp.normalize(transcription)
+
+            data[file_name] = {
+                "id": int(_id),
+                "raw_transcription": raw_transcription,
+                "transcription": transcription,
+                "num_samples": int(num_samples),
+                "gender": gender_to_id[gender],
+                "lang_id": _FLEURS_LANG.index(lang_id),
+                "language": _FLEURS_LANG_TO_LONG[lang_id],
+                "lang_group_id": list(_FLEURS_GROUP_TO_LONG.keys()).index(
+                    lang_group
+                ),
+            }
+
+        return data
+
+    def _generate_examples(self, local_extracted_archive, archive_iters, audio_path, text_path):
+        key = 0
+
+        for lang_id, archive_iter in archive_iters.items():
+            with open(text_path[lang_id], encoding="utf-8") as f:
+                lines = f.readlines()
+                data = self._get_data(lines, lang_id)
+
+            for path, f in archive_iter:
+                path = path.split("/")[-1]
+                if path not in data.keys():
+                    continue
+
+                result = data[path]
+                extracted_audio_path = (
+                    os.path.join(local_extracted_archive[lang_id], audio_path[lang_id])
+                    if local_extracted_archive is not None
+                    else None
+                )
+                extracted_audio_path = os.path.join(extracted_audio_path, path) if extracted_audio_path else path
+                result["path"] = extracted_audio_path if extracted_audio_path is not None else None
+                result["audio"] = {"path": path, "bytes": f.read()}
+                yield key, result
+                key += 1

text_processor/currency.tsv

@@ -0,0 +1,35 @@
+US$	dollar amerika serikat
+nzd	dollar new zealand
+rs	rupee
+chf	franc swiss
+dkk	kroner denmark
+fim	markka finland
+aed	dirham arab
+czk	koruna ceko
+mro	ouguiya mauritania
+pkr	rupee pakistan
+crc	colon costa rica
+hk$	dollar hong kong
+npr	rupee nepal
+awg	florin aruban
+nok	kroner norwegia
+tzs	shilling tanzania
+sek	kronor swedish
+cyp	pounds cypriot
+sar	riyal saudi
+cve	escudo cape verde
+rsd	dinar serbia
+dm	mark jerman
+shp	pounds saint helena
+php	peso philipina
+cad	dollar canada
+ssp	pounds sudan selatan
+scr	rupee seychell
+mvr	rufiyaa maldivia
+Rp	rupiah
+r	real
+$	dollar
+€	euro
+£	pounds
+₩	won
+¥	yen

text_processor/measurements.tsv

@@ -0,0 +1,116 @@
+sq mi	mil kuadrat
+sq ft	kaki kuadrat
+kbps	kilobit per detik
+mbps	megabit per detik
+kcal	kilo kalori
+ghz	gigahertz
+khz	kilohertz
+mhz	megahertz
+lbs	pound
+rpm	revolution per menit
+kwh	kilo watt jam
+min	menit
+mph	mil per jam
+mol	mol
+gpa	giga pascal
+km²	kilometer kuadrat
+km2	kilometer kuadrat
+rad	radian
+kgf	kilogram force
+mm²	millimeter kuadrat
+mm2	millimeter kuadrat
+cm²	centimeter kuadrat
+cm2	centimeter kuadrat
+dm³	desimeter kubik
+dm3	desimeter kubik
+amu	atomic mass unit
+gwh	giga watt jam
+kpa	kilopascal
+cwt	hundredweight
+atm	atmosphere
+bar	bar
+km	kilometer
+cm	centimeter
+mm	millimeter
+ha	hectare
+mi	mil
+m²	meter kuadrat
+m2	meter kuadrat
+ft	kaki
+hz	hertz
+kw	kilowatt
+hp	tenaga kuda
+mg	milligram
+kg	kilogram
+lb	pound
+mc	mega coulomb
+nm	nanometer
+mA	milli ampere
+m³	meter kubik
+m3	meter kubik
+tw	tera watt
+mv	milli volt
+mw	megawatt
+μm	mikrometer
+"	inch
+TB	terabyte
+cc	c c
+da	dalton
+db	desibel
+ps	peta detik
+oz	ounce
+hl	hecto liter
+μg	mikrogram
+pg	petagram
+GB	gigabyte
+kb	kilobit
+ev	electron volt
+MB	megabyte
+KB	kilobyte
+kl	kilo liter
+tj	tera joule
+kv	kilo volt
+mv	mega volt
+kn	kilonewton
+mm	megameter
+au	astronomical unit
+yd	yard
+lm	lumen
+hs	hecto detik
+ml	milliliter
+gw	gigawatt
+ma	mega ampere
+kt	knot
+ng	nano gram
+ns	nano detik
+ms	mega siemens
+gl	giga liter
+μs	mikro detik
+da	desi ampere
+pa	pascal
+ds	desi detik
+ms	milli detik
+dm	desimeter
+mb	megabit
+mf	mega farad
+bq	becquerel
+pb	petabit
+cd	candela
+tl	tera liter
+ms	mega detik
+mpa	megapascal
+pb	peta byte
+gy	gray
+sv	sievert
+cc	c c
+°F	derajat fahrenheit
+°f	derajat fahrenheit
+°C	derajat celsius
+°c	derajat celsius
+m	meter
+%	percent
+v	volt
+h	jam
+g	gram
+s	detik
+ω	ohm

text_processor/text_processor.py

@@ -0,0 +1,182 @@
+import re
+from num2words import num2words
+import os
+
+
+def get_abs_path(rel_path):
+    """
+    Get absolute path
+    Args:
+        rel_path: relative path to this file
+
+    Returns absolute path
+    """
+    return os.path.dirname(os.path.abspath(__file__)) + '/' + rel_path
+
+
+class TextProcessor:
+    thousands = ["ratus", "ribu", "juta", "miliar", "milyar", "triliun"]
+    months = ["Januari", "Februari", "Maret", "April",
+              "Mei", "Juni", "Juli", "Agustus",
+              "September", "Oktober", "November", "Desember"]
+    measurements_path = get_abs_path("measurements.tsv")
+    currencies_path = get_abs_path("currency.tsv")
+    timezones_path = get_abs_path("timezones.tsv")
+
+    def __init__(self):
+        self.measurements = {}
+        with open(TextProcessor.measurements_path, "r") as file:
+            for line in file:
+                line = line.strip().split("\t")
+                self.measurements[line[0]] = line[1]
+
+        self.currencies = {}
+        with open(TextProcessor.currencies_path, "r") as file:
+            for line in file:
+                line = line.strip().split("\t")
+                self.currencies[line[0]] = line[1]
+
+        self.timezones = {}
+        with open(TextProcessor.timezones_path, "r") as file:
+            for line in file:
+                line = line.strip().split("\t")
+                self.timezones[line[0]] = line[1]
+
+        self.re_thousands = '|'.join([t for t in TextProcessor.thousands])
+        self.re_currencies = r'\b' + re.sub(r'\|([^|$£€¥₩]+)', r'|\\b\1', '|'.join([c for c in self.currencies]))
+        self.re_currencies = re.sub(r'([$£€¥₩])', r'\\\1', self.re_currencies)
+        self.re_moneys = r'(({}) ?([\d\.\,]+)( ({})?(an)?)?)'.format(self.re_currencies, self.re_thousands)
+        self.re_measurements = '|'.join([t for t in self.measurements])
+        self.re_measurements = r'(\b([\d\.\,]+) ?({})\b)'.format(self.re_measurements)
+        self.re_timezones = '|'.join([c for c in self.timezones])
+        self.re_timezones = r'((\d{1,2})[\.:](\d{1,2}) ' + r'\b({})\b)'.format(self.re_timezones)
+        self.re_http = r'(https?://(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b[-a-zA-Z0-9()@:%_\+.~#?&//=]*)'
+
+    @staticmethod
+    def is_integer(number):
+        try:
+            int(number)
+            return True
+        except ValueError:
+            return False
+
+    @staticmethod
+    def is_float(number):
+        try:
+            float(number)
+            return True
+        except ValueError:
+            return False
+
+    def normalize(self, text):
+        found_errors = False
+        # Remove URL
+        urls = re.findall(self.re_http, text)
+        for url in urls:
+            text = text.replace(url[0], "")
+
+        # Currency
+        moneys = re.findall(self.re_moneys, text)
+        for money in moneys:
+            number = re.sub(',', '.', re.sub(r'\.', '', money[2].strip(" ,.")))
+            try:
+                if number == "":
+                    continue
+                if self.is_integer(number):
+                    number = int(number)
+                elif self.is_float(number):
+                    number = float(number)
+                else:
+                    number = re.sub(r'[.,]', "", number)
+                    number = int(number)
+                number = num2words(number, to='cardinal', lang='id')
+                text = text.replace(money[0].strip(" ,."), f'{number} {money[3]} {self.currencies[money[1]]}')
+            except Exception as error:
+                found_errors = True
+                print(error)
+                print(f'Problem with money: <{text}>: {number}')
+
+        # Measurements
+        units = re.findall(self.re_measurements, text)
+        for unit in units:
+            number = re.sub(',', '.', re.sub(r'\.', '', unit[1].strip(" ,.")))
+            try:
+                if number == "":
+                    continue
+                if re.search(r'\.', number):
+                    number = float(number)
+                else:
+                    number = int(number)
+                number = num2words(number, to='cardinal', lang='id')
+                text = text.replace(unit[0].strip(" ,."), f'{number} {self.measurements[unit[2]]}')
+            except Exception as error:
+                found_errors = True
+                print(error)
+                print(f'Problem with measurements: <{text}>: {number}')
+
+        # Date
+        dates = re.findall(r'(\((\d{1,2})/(\d{1,2})(/(\d+))?\))', text)
+        for date in dates:
+            try:
+                day = num2words(int(date[1]), to='cardinal', lang='id')
+                month = int(date[2]) - 1
+                if month >= 12:
+                    month = 0
+                month = self.months[month]
+                if date[4] != "":
+                    year = num2words(int(date[4]), to='cardinal', lang='id')
+                    date_string = f'{day} {month} {year}'
+                else:
+                    date_string = f'{day} {month}'
+                text = text.replace(date[0], f' {date_string} ')
+            except Exception as error:
+                found_errors = True
+                print(error)
+                print(f'Problem with dates: <{text}>: {date}')
+
+        # Timezones
+        timezones = re.findall(self.re_timezones, text)
+        for timezone in timezones:
+            try:
+                hour = num2words(int(timezone[1]), to='cardinal', lang='id')
+                minute = num2words(int(timezone[2]), to='cardinal', lang='id')
+                zone = self.timezones[timezone[3]]
+                if minute == "nol":
+                    time_string = f'{hour} {zone}'
+                else:
+                    time_string = f'{hour} lewat {minute} menit {zone}'
+                text = text.replace(timezone[0], f'{time_string}')
+            except Exception as error:
+                found_errors = True
+                print(error)
+                print(f'Problem with timezones: <{text}>: {timezone}')
+
+        # Any number
+        re_numbers = [r'([\d.,]+)', r'\d+']
+        for re_number in re_numbers:
+            number_len = 0
+            for i in re.finditer(re_number, text):
+                start = i.start() + number_len
+                end = i.end() + number_len
+                number = text[start:end]
+                number = re.sub(',', '.', re.sub(r'\.', '', number.strip(" ,.")))
+                if number == "":
+                    continue
+                if self.is_integer(number) or self.is_float(number):
+                    try:
+                        if self.is_integer(number):
+                            number = int(number)
+                        else:
+                            number = float(number)
+                        number = num2words(number, to='cardinal', lang="id")
+                        text = text[:start] + number + text[end:]
+                        number_len += len(number) - (end - start)
+                    except Exception as error:
+                        found_errors = True
+                        print(error)
+                        print(f'Problem with number: <{text}>: {number}')
+
+        text = re.sub(r"\s+", " ", text)
+        if found_errors:
+            print(f'>>> {text}')
+        return text

text_processor/timezones.tsv

@@ -0,0 +1,4 @@
+WITA	Waktu Indonesia Tengah
+WIB	Waktu Indonesia Barat
+WIT	Waktu Indonesia Timur
+GMT	Greenwich Mean Time