Merge remote-tracking branch 'origin/main' into main

README.md

@@ -1,8 +1,4 @@
 ---
-annotations_creators:
-- SLPL
-language_creators:
-- SLPL
 language:
 - fa
 license:
@@ -11,8 +7,6 @@ multilinguality:
 - monolingual
 size_categories:
 - 200M<n<300M
-source_datasets:
-- commoncrawl
 task_categories:
 - language-modeling
 - masked-language-modeling
@@ -23,6 +17,7 @@ pretty_name: naab (A ready-to-use plug-and-play corpus in Farsi)
 ---
 
 # naab: A ready-to-use plug-and-play corpus in Farsi
+_[If you want to join our community to keep up with news, models and datasets from naab, click on [this](https://docs.google.com/forms/d/e/1FAIpQLSe8kevFl_ODCx-zapAuOIAQYr8IvkVVaVHOuhRL9Ha0RVJ6kg/viewform) link.]_
 
 ## Table of Contents
 - [Dataset Card Creation Guide](#dataset-card-creation-guide)
@@ -39,15 +34,7 @@ pretty_name: naab (A ready-to-use plug-and-play corpus in Farsi)
     - [Curation Rationale](#curation-rationale)
     - [Source Data](#source-data)
       - [Initial Data Collection and Normalization](#initial-data-collection-and-normalization)
-      - [Who are the source language producers?](#who-are-the-source-language-producers)
-    - [Annotations](#annotations)
-      - [Annotation process](#annotation-process)
-      - [Who are the annotators?](#who-are-the-annotators)
     - [Personal and Sensitive Information](#personal-and-sensitive-information)
-  - [Considerations for Using the Data](#considerations-for-using-the-data)
-    - [Social Impact of Dataset](#social-impact-of-dataset)
-    - [Discussion of Biases](#discussion-of-biases)
-    - [Other Known Limitations](#other-known-limitations)
   - [Additional Information](#additional-information)
     - [Dataset Curators](#dataset-curators)
     - [Licensing Information](#licensing-information)
@@ -57,140 +44,124 @@ pretty_name: naab (A ready-to-use plug-and-play corpus in Farsi)
 ## Dataset Description
 
 - **Homepage:** [Sharif Speech and Language Processing Lab](https://huggingface.co/SLPL)
-- **Repository:** [If the dataset is hosted on github or has a github homepage, add URL here]()
 - **Paper:** [If the dataset was introduced by a paper or there was a paper written describing the dataset, add URL here (landing page for Arxiv paper preferred)]()
-- **Leaderboard:** [If the dataset supports an active leaderboard, add link here]()
-- **Point of Contact:** [If known, name and email of at least one person the reader can contact for questions about the dataset.]()
+- **Point of Contact:** [Sadra Sabouri](mailto:sabouri.sadra@gmail.com)
 
 ### Dataset Summary
+naab is the biggest cleaned and ready-to-use open-source textual corpus in Farsi. It contains about 130GB of data, 250 million paragraphs, and 15 billion words. The project name is derived from the Farsi word ناب which means pure and high-grade. We also provide the raw version of the corpus called naab-raw and an easy-to-use pre-processor that can be employed by those who wanted to make a customized corpus.
 
-Briefly summarize the dataset, its intended use and the supported tasks. Give an overview of how and why the dataset was created. The summary should explicitly mention the languages present in the dataset (possibly in broad terms, e.g. *translations between several pairs of European languages*), and describe the domain, topic, or genre covered.
+You can use this corpus by the commands below:
+```python
+from datasets import load_dataset
 
-### Supported Tasks and Leaderboards
+dataset = load_dataset("SLPL/naab")
+```
+_Note: be sure that your machine has at least 130 GB free space, also it may take a while to download._
 
-For each of the tasks tagged for this dataset, give a brief description of the tag, metrics, and suggested models (with a link to their HuggingFace implementation if available). Give a similar description of tasks that were not covered by the structured tag set (repace the `task-category-tag` with an appropriate `other:other-task-name`).
+You may need to download parts/splits of this corpus too, if so use the command below (You can find more ways to use it [here](https://huggingface.co/docs/datasets/loading#slice-splits)):
+```python
+from datasets import load_dataset
 
-- `task-category-tag`: The dataset can be used to train a model for [TASK NAME], which consists in [TASK DESCRIPTION]. Success on this task is typically measured by achieving a *high/low* [metric name](https://huggingface.co/metrics/metric_name). The ([model name](https://huggingface.co/model_name) or [model class](https://huggingface.co/transformers/model_doc/model_class.html)) model currently achieves the following score. *[IF A LEADERBOARD IS AVAILABLE]:* This task has an active leaderboard which can be found at [leaderboard url]() and ranks models based on [metric name](https://huggingface.co/metrics/metric_name) while also reporting [other metric name](https://huggingface.co/metrics/other_metric_name).
+dataset = load_dataset("SLPL/naab", split="train[:10%]")
+```
 
-### Languages
+### Supported Tasks and Leaderboards
 
-Provide a brief overview of the languages represented in the dataset. Describe relevant details about specifics of the language such as whether it is social media text, African American English,...
+This corpus can be used for training all language models which can be trained by Masked Language Modeling (MLM) or any other self-supervised objective.
 
-When relevant, please provide [BCP-47 codes](https://tools.ietf.org/html/bcp47), which consist of a [primary language subtag](https://tools.ietf.org/html/bcp47#section-2.2.1), with a [script subtag](https://tools.ietf.org/html/bcp47#section-2.2.3) and/or [region subtag](https://tools.ietf.org/html/bcp47#section-2.2.4) if available.
+- `language-modeling`
+- `masked-language-modeling`
 
 ## Dataset Structure
 
-### Data Instances
-
-Provide an JSON-formatted example and brief description of a typical instance in the dataset. If available, provide a link to further examples.
-
-```
+Each row of the dataset will look like something like the below:
+```json
 {
-  'example_field': ...,
-  ...
+  'text': "این یک تست برای نمایش یک پاراگراف در پیکره متنی ناب است.",
 }
 ```
++ `text` : the textual paragraph.
 
-Provide any additional information that is not covered in the other sections about the data here. In particular describe any relationships between data points and if these relationships are made explicit.
-
-### Data Fields
-
-List and describe the fields present in the dataset. Mention their data type, and whether they are used as input or output in any of the tasks the dataset currently supports. If the data has span indices, describe their attributes, such as whether they are at the character level or word level, whether they are contiguous or not, etc. If the datasets contains example IDs, state whether they have an inherent meaning, such as a mapping to other datasets or pointing to relationships between data points.
-
-- `example_field`: description of `example_field`
-
-Note that the descriptions can be initialized with the **Show Markdown Data Fields** output of the [Datasets Tagging app](https://huggingface.co/spaces/huggingface/datasets-tagging), you will then only need to refine the generated descriptions.
 
 ### Data Splits
 
-Describe and name the splits in the dataset if there are more than one.
-
-Describe any criteria for splitting the data, if used. If there are differences between the splits (e.g. if the training annotations are machine-generated and the dev and test ones are created by humans, or if different numbers of annotators contributed to each example), describe them here.
-
-Provide the sizes of each split. As appropriate, provide any descriptive statistics for the features, such as average length.  For example:
+This dataset includes two splits (`train` and `test`). We split these two by dividing the randomly permuted version of the corpus into (95%, 5%) division respected to (`train`, `test`). Since `validation` is usually occurring during training with the `train` dataset we avoid proposing another split for it.
 
 |                         | train | test |
 |-------------------------|------:|-----:|
-| Input Sentences         |       |      |
-| Average Sentence Length |       |      |
-
-## Dataset Creation
-
-### Curation Rationale
+| Input Sentences         |   225892925   |   11083851   |
+| Average Sentence Length |   61    |   25   |
 
-What need motivated the creation of this dataset? What are some of the reasons underlying the major choices involved in putting it together?
+Below you can see the log-based histogram of word/paragraph over the two splits of the dataset.
 
-### Source Data
-
-This section describes the source data (e.g. news text and headlines, social media posts, translated sentences,...)
+<div align="center">
+<img src="https://huggingface.co/datasets/SLPL/naab/resolve/main/naab-hist.png">
+</div>
 
-#### Initial Data Collection and Normalization
-
-Describe the data collection process. Describe any criteria for data selection or filtering. List any key words or search terms used. If possible, include runtime information for the collection process.
+## Dataset Creation
 
-If data was collected from other pre-existing datasets, link to source here and to their [Hugging Face version](https://huggingface.co/datasets/dataset_name).
+### Curation Rationale
 
-If the data was modified or normalized after being collected (e.g. if the data is word-tokenized), describe the process and the tools used.
+Due to the lack of a huge amount of text data in lower resource languages - like Farsi - researchers working on these languages were always finding it hard to start to fine-tune such models. This phenomenon can lead to a situation in which the golden opportunity for fine-tuning models is just in hands of a few companies or countries which contributes to the weakening the open science.
 
-#### Who are the source language producers?
+The last biggest cleaned merged textual corpus in Farsi is a 70GB cleaned text corpus from a compilation of 8 big data sets that have been cleaned and can be downloaded directly. Our solution to the discussed issues is called naab. It provides **126GB** (including more than **224 million** sequences and nearly **15 billion** words) as the training corpus and **2.3GB** (including nearly **11 million** sequences and nearly **300 million** words) as the test corpus.
 
-State whether the data was produced by humans or machine generated. Describe the people or systems who originally created the data.
+### Source Data
 
-If available, include self-reported demographic or identity information for the source data creators, but avoid inferring this information. Instead state that this information is unknown. See [Larson 2017](https://www.aclweb.org/anthology/W17-1601.pdf) for using identity categories as a variables, particularly gender.
+The textual corpora that we used as our source data are illustrated in the figure below. It contains 5 corpora which are linked in the coming sections.
 
-Describe the conditions under which the data was created (for example, if the producers were crowdworkers, state what platform was used, or if the data was found, what website the data was found on). If compensation was provided, include that information here.
+<div align="center">
+<img src="https://huggingface.co/datasets/SLPL/naab/resolve/main/naab-pie.png">
+</div>
 
-Describe other people represented or mentioned in the data. Where possible, link to references for the information.
+#### Persian NLP
 
-### Annotations
+[This](https://github.com/persiannlp/persian-raw-text) corpus includes eight corpora that are sorted based on their volume as below:
 
-If the dataset contains annotations which are not part of the initial data collection, describe them in the following paragraphs.
+ - [Common Crawl](https://commoncrawl.org/): 65GB ([link](https://storage.googleapis.com/danielk-files/farsi-text/merged_files/commoncrawl_fa_merged.txt))
+ - [MirasText](https://github.com/miras-tech/MirasText): 12G 
+ - [W2C – Web to Corpus](https://lindat.mff.cuni.cz/repository/xmlui/handle/11858/00-097C-0000-0022-6133-9): 1GB ([link](https://storage.googleapis.com/danielk-files/farsi-text/merged_files/w2c_merged.txt))
+ - Persian Wikipedia (March 2020 dump): 787MB ([link](https://storage.googleapis.com/danielk-files/farsi-text/merged_files/fawiki_merged.txt))
+ - [Leipzig Corpora](https://corpora.uni-leipzig.de/): 424M ([link](https://storage.googleapis.com/danielk-files/farsi-text/merged_files/LeipzigCorpus.txt))
+ - [VOA corpus](https://jon.dehdari.org/corpora/): 66MB ([link](https://storage.googleapis.com/danielk-files/farsi-text/merged_files/voa_persian_2003_2008_cleaned.txt))
+ - [Persian poems corpus](https://github.com/amnghd/Persian_poems_corpus): 61MB ([link](https://storage.googleapis.com/danielk-files/farsi-text/merged_files/poems_merged.txt))
+ - [TEP: Tehran English-Persian parallel corpus](http://opus.nlpl.eu/TEP.php): 33MB ([link](https://storage.googleapis.com/danielk-files/farsi-text/merged_files/TEP_fa.txt))
+ 
+#### AGP
+This corpus was a formerly private corpus for ASR Gooyesh Pardaz which is now published for all users by this project. This corpus contains more than 140 million paragraphs summed up in 23GB (after cleaning). This corpus is a mixture of both formal and informal paragraphs that are crawled from different websites and/or social media.
 
-#### Annotation process
+#### OSCAR-fa
+[OSCAR](https://oscar-corpus.com/) or Open Super-large Crawled ALMAnaCH coRpus is a huge multilingual corpus obtained by language classification and filtering of the Common Crawl corpus using the go classy architecture. Data is distributed by language in both original and deduplicated form. We used the unshuffled-deduplicated-fa from this corpus, after cleaning there were about 36GB remaining.
 
-If applicable, describe the annotation process and any tools used, or state otherwise. Describe the amount of data annotated, if not all. Describe or reference annotation guidelines provided to the annotators. If available, provide interannotator statistics. Describe any annotation validation processes.
+#### Telegram
+Telegram, a cloud-based instant messaging service, is a widely used application in Iran. Following this hypothesis, we prepared a list of Telegram channels in Farsi covering various topics including sports, daily news, jokes, movies and entertainment, etc. The text data extracted from mentioned channels mainly contains informal data.
 
-#### Who are the annotators?
+#### LSCP
+[The Large Scale Colloquial Persian Language Understanding dataset](https://iasbs.ac.ir/~ansari/lscp/) has 120M sentences from 27M casual Persian sentences with its derivation tree, part-of-speech tags, sentiment polarity, and translations in English, German, Czech, Italian, and Hindi. However, we just used the Farsi part of it and after cleaning we had 2.3GB of it remaining. Since the dataset is casual, it may help our corpus have more informal sentences although its proportion to formal paragraphs is not comparable.
 
-If annotations were collected for the source data (such as class labels or syntactic parses), state whether the annotations were produced by humans or machine generated.
+#### Initial Data Collection and Normalization
 
-Describe the people or systems who originally created the annotations and their selection criteria if applicable.
+The data collection process was separated into two parts. In the first part, we searched for existing corpora. After downloading these corpora we started to crawl data from some social networks. Then thanks to [ASR Gooyesh Pardaz](https://asr-gooyesh.com/en/) we were provided with enough textual data to start the naab journey.
 
-If available, include self-reported demographic or identity information for the annotators, but avoid inferring this information. Instead state that this information is unknown. See [Larson 2017](https://www.aclweb.org/anthology/W17-1601.pdf) for using identity categories as a variables, particularly gender.
+We used a preprocessor based on some stream-based Linux kernel commands so that this process can be less time/memory-consuming. The code is provided [here](https://github.com/Sharif-SLPL/t5-fa/tree/main/preprocess).
 
-Describe the conditions under which the data was annotated (for example, if the annotators were crowdworkers, state what platform was used, or if the data was found, what website the data was found on). If compensation was provided, include that information here.
 
 ### Personal and Sensitive Information
 
-State whether the dataset uses identity categories and, if so, how the information is used. Describe where this information comes from (i.e. self-reporting, collecting from profiles, inferring, etc.). See [Larson 2017](https://www.aclweb.org/anthology/W17-1601.pdf) for using identity categories as a variables, particularly gender. State whether the data is linked to individuals and whether those individuals can be identified in the dataset, either directly or indirectly (i.e., in combination with other data).
-
-State whether the dataset contains other data that might be considered sensitive (e.g., data that reveals racial or ethnic origins, sexual orientations, religious beliefs, political opinions or union memberships, or locations; financial or health data; biometric or genetic data; forms of government identification, such as social security numbers; criminal history).  
+Since this corpus is briefly a compilation of some former corpora we take no responsibility for personal information included in this corpus. If you detect any of these violations please let us know, we try our best to remove them from the corpus ASAP.
 
-If efforts were made to anonymize the data, describe the anonymization process.
-
-## Considerations for Using the Data
-
-### Social Impact of Dataset
-
-Farsi is a language used by millions of people, for thousands of years; therefore, there exists numerous resources for this language. However, no-one has ever published a big enough easy to use corpus of textual data. Our dataset eases the path of pre-training and fine-tuning Farsi Language Models (LMs) in self-supervised manner which can lead to better tools for retention and development of Farsi. As a matter of fact, the informal portion of naab contains various dialects including, Turkish, Luri, etc. which are under-represented languages. Although the amount of data is comparably small, but it can be helpful in training a multi-lingual Tokenizer for Farsi variations. As mentioned before, some parts of our dataset are crawled from social media which in result means it contains ethnic, religious, and gender biases.
-
-### Discussion of Biases
-
-During Exploratory Data Analysis (EDA), we found samples of data including biased opinions about race, religion, and gender. Based on the result we saw in our samples, only a small portion of informal data can be considered biased. Therefore, we anticipate that it won’t affect the trained language model on this data. Furthermore, we decided to keep this small part of data as it may become helpful in training models for classifying harmful and hateful texts.
-
-### Other Known Limitations
-
-If studies of the datasets have outlined other limitations of the dataset, such as annotation artifacts, please outline and cite them here.
+We tried our best to provide anonymity while keeping the crucial information. We shuffled some parts of the corpus so the information passing through possible conversations wouldn't be harmful. 
 
 ## Additional Information
 
 ### Dataset Curators
 
-List the people involved in collecting the dataset and their affiliation(s). If funding information is known, include it here.
++ Sadra Sabouri (Sharif University of Technology)
++ Elnaz Rahmati (Sharif University of Technology)
 
 ### Licensing Information
 
-Provide the license and link to the license webpage if available.
+mit?
 
 ### Citation Information
 
@@ -209,3 +180,11 @@ If the dataset has a [DOI](https://www.doi.org/), please provide it here.
 ### Contributions
 
 Thanks to [@sadrasabouri](https://github.com/sadrasabouri) and [@elnazrahmati](https://github.com/elnazrahmati) for adding this dataset.
+
+### Keywords
++ Farsi
++ Persian
++ raw text
++ پیکره فارسی
++ پیکره متنی
++ آموزش مدل زبانی

naab.py

@@ -0,0 +1,119 @@
+# Copyright 2020 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.
+"""naab: A ready-to-use plug-and-play corpus in Farsi"""
+
+
+import csv
+import json
+import os
+
+import datasets
+
+
+# TODO: Add BibTeX citation
+# Find for instance the citation on arxiv or on the dataset repo/website
+_CITATION = """\
+"""
+
+# You can copy an official description
+_DESCRIPTION = """\
+Huge corpora of textual data are always known to be a crucial need for training deep models such as transformer-based ones. This issue is emerging more in lower resource languages - like Farsi. We propose naab, the biggest cleaned and ready-to-use open-source textual corpus in Farsi. It contains about 130GB of data, 250 million paragraphs, and 15 billion words. The project name is derived from the Farsi word ناب which means pure and high-grade.
+"""
+
+_HOMEPAGE = "https://huggingface.co/datasets/SLPL/naab"
+
+# TODO: ?
+_LICENSE = "mit"
+
+N_FILES = {
+    "train": 126,
+    "test": 3
+}
+_BASE_URL = "https://huggingface.co/datasets/SLPL/naab/resolve/main/data/"
+_URLS = {
+    "train": [_BASE_URL + "train-{:05d}-of-{:05d}.txt".format(x, N_FILES["train"]) for x in range(N_FILES["train"])],
+    "test": [_BASE_URL + "test-{:05d}-of-{:05d}.txt".format(x, N_FILES["test"]) for x in range(N_FILES["test"])],
+}
+VERSION = datasets.Version("1.0.0")
+
+
+class NaabConfig(datasets.BuilderConfig):
+    """BuilderConfig for naab."""
+
+    def __init__(self, *args, **kwargs):
+        """BuilderConfig for naab.
+        Args:
+            **kwargs: keyword arguments forwarded to super.
+        """
+        super(NaabConfig, self).__init__(*args, **kwargs)
+
+
+class Naab(datasets.GeneratorBasedBuilder):
+    """naab: A ready-to-use plug-and-play corpus in Farsi."""
+    
+    BUILDER_CONFIGS = [
+        NaabConfig(
+          name="all",
+          version=VERSION,
+          description=_DESCRIPTION)
+    ]
+    BUILDER_CONFIG_CLASS = NaabConfig
+
+    DEFAULT_CONFIG_NAME = "all"
+
+    def _info(self):
+        features = datasets.Features({
+                    "text": datasets.Value("string"),
+        })
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            supervised_keys=None,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        data_urls = {}
+        for split in ["train", "test"]:
+            data_urls[split] = _URLS[split]
+        
+        train_downloaded_files = dl_manager.download(data_urls["train"])
+        test_downloaded_files = dl_manager.download(data_urls["test"])
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "filepath": train_downloaded_files,
+                    "split": "train"
+                }
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "filepath": test_downloaded_files,
+                    "split": "test"
+                }
+            ),
+        ]
+ 
+
+    def _generate_examples(self, filepath, split):
+        with open(filepath, encoding="utf-8") as f:
+            for key, row in enumerate(f):
+                if row.strip():
+                    yield idx, {"text": row}
+                else:
+                    yield idx, {"text": ""}