Update README.md

README.md

@@ -48,14 +48,16 @@ Each line of a file is a sample formatted in JSON with the following layout:
 
 ```json
 {
-  "id": <integer>,
+  "id": <A sequential integer>,
   "text": "<A Farsi sentence>",
-  "source": "<One of the aformentioned sources>"
+  "source": "<One of: []>"
 }
 ```
 
 ## Data curation process
 
+### 1. Preprocessing
+
 The value of this dataset is its preprocessing of the text. The main struggle working with Farsi text is the fact that due to some historical challenges, there are so many different codings out there used to save Farsi text. On top of that, you can add the complexity of dealing with multiple character codes for the same letter. In Farsi, the look of a character depends on its neighbouring characters. For example, consider the final letter of Farsi alphabet "Ye":
 
 It has a standalone shape:
@@ -66,22 +68,99 @@ But when surronded with other characters, its middle form is used:
 
 <pre><font size="7">&#64511;</font></pre>
 
-This requirement is taken care of by "fonts' substitution table" feature. Which will help show the correct form of the words. But at the same time, some text don't rely on the fonts and use the specific code defined for the middle form directly. From the reader point of the view, both will look identical but printing the code, you'll have different numbers. This complicates text processing in Farsi since we need to identify each character with a unique code regardless of their position in the word. On top of that, add the problem of using Arabic characters to type Farsi text. Again, since the two languages share very similar alphabets, one can successfully read a text in Farsi while it's been typed by Arabic characters since they look very similar in shape.
+This requirement is usually taken care of by "substitution table" feature of the fonts. Which will help show the correct form of the letters. But at the same time, some text don't rely on the fonts and use the specific code designed for the specific form of the letters directly. From the reader point of the view, both will look identical but printing the code, you'll have different numbers. This complicates text processing in Farsi since we need to identify each character with a unique code regardless of their position in the word. On top of that, add the problem of using Arabic characters which some times are used to type Farsi text. Again, since the two languages share very similar alphabets (visually speaking), one can successfully read a text in Farsi while it's been typed using Arabic characters.
 
-To address these problems, the preprocessing used in Jomle tries its best to map all the different characters that look alike to the Farsi counterpart. This is not an exact science but based on the best effort.
+To address these problems, the preprocessing used in Jomle tries its best to map all the different characters that look alike to their Farsi counterpart. This is not an exact science but based on the best effort. For instance, if a sentence is actually an Arabic sentence, the preprocessing script used here will make things worse. But assuming that all the text used here as source are 100% Farsi, this script should help make them uniform.
 
-The same could be said about digits and punctuations.
+The same cleaning process also includes digits and puncuations.
 
 At the end, any character that can be found in the Jomleh dataset is either:
 
-- a Farsi alphabet letter (`آ` to `ی`)
-- a Farsi digit (`۱` to `۰`)
-- a Zero-width non-joiner (`\u200c`)
-- a Space
-- a Dot/period (`.`)
-- an exclamation mark (`!`)
-- a Farsi question mark (`؟`)
-- a Farsi comma (`،`)
+- a Farsi alphabet letter (`ا` to `ی`) or
+- one of the: `آ`, `أ`, `ؤ`, `ئ` or
+- a Farsi digit (`۹` to `۰`) or
+- a zero-width non-joiner (`\u200c`) or
+- a space or
+- one of the Farsi punctuations (`.`, `!`, `؟`, `،`, `؛`)
 
 Any other character found in the text is eliminated based on best effort and if the elimination of such characters could harm the integrity and the meaning of the sentence, then that sentence is removed from the dataset altogether.
 
+The script used for the preprocessing can be found [here](/datasets/mlengineer-ai/jomleh/blob/main/preprocess.py).
+
+It's also worth mentioning that the preprocessing script will convert the text into vertical format which is expected by the third step (deduplication). Simply put, vertical format replaces spaces with a line feed. And also surround it with a `<doc>` tag. Here's an example sample converted into vertical format:
+
+```
+<doc id="poems_merged.txt_3">
+این
+درگه
+ما
+درگه
+نومیدی
+نیست.
+</doc>
+```
+
+The `id` attribute of the `<doc>` tag points to the file where the sample is coming from.
+
+This is the command that executes the preprocessing script:
+
+```
+find 1_prepared -name "*.txt" | parallel 'python ./processing/preprocess.py $(basename {}) < {} > ./2_cleaned_vertical/$(basename {})'
+```
+
+### 2. Merging into one text file
+
+Once the raw source data was preprocessed, they are merged into a single large text file. This can easily be accomplished using a single command:
+
+```
+cat ./2_cleaned_vertical/* > ./3_temp/clean_merged.vert
+```
+
+### 3. Deduplication
+
+Once all the text is transformed into vertical format and saved in a single text file, `onion` program is used to eliminate any duplicate samples. You can find the onion program from [this website](https://corpus.tools/wiki/Onion) and it is used here like this:
+
+```
+onion -sm -n 5 -t 0.5 ./3_temp/clean_merged.vert > ./3_temp/deduplicated.vert
+```
+
+### 4. Postprocessing
+
+The postprocessing involves:
+
+1. Converting back from vertical format into a single line per sample.
+2. Mapping the file name mentioned in the `id` attribute of the `<doc>` tag into a simpler text which can be found in the [postprocessing script](/datasets/mlengineer-ai/jomleh/blob/main/postprocessing.py).
+3. Formatting each sample as a JSON-line (one json per line)
+4. Distributing and saving the sample unifomrly across 60 files, trying to get relatively same number of samples per file.
+5. Collection some statistics along the way.
+
+These steps are run using the following command:
+
+```
+python ./postprocess.py ./3_temp < ./3_temp/deduplicated.vert | parallel "echo '{}' | python ./processing/add_id.py ./3_temp ./jomleh/files"
+```
+
+### 5. Compressing the files
+
+This can be done using the following command:
+
+```
+find ./jomleh/files/*.jsonl -type f | parallel 'zstd {}'
+```
+
+### 6. Generating the checksum file
+
+```
+ls ./jomleh/files/*.zst | sort -t _ -k 2 -n | xargs sha256sum > ./jomleh/files/checksum.sha256
+```
+
+After applying all these steps, we are left a dataset with these characteristics:
+
+| | Some statistics on the collected sentences |
+|---:|:---|
+| Total number of sentences: | 123 | 
+| Average number of characters in a sentence: | 123 |
+| Average number of words in a sentence: | 123 |
+| Standard devitaion for the number of words in a sentence: | 123 |
+| Average number of letters in a word: | 123 |
+| Standard devitaion for the number of letters in a word: | 123 |