Duplicate from Mavkif/Roman-Urdu-Parl-split

Co-authored-by: Umer <Mavkif@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,2 @@
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.txt filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,125 @@
+---
+license: apache-2.0
+task_categories:
+- translation
+language:
+- ur
+tags:
+- urdu
+- translation
+- Transliteration
+- parallel
+- dataset
+pretty_name: Roman Urdu Parl
+size_categories:
+- 1M<n<10M
+---
+
+# Roman Urdu Parallel Dataset - Split
+
+This dataset is just another version of Roman-Urdu-Parl dataset split into train, validation and test set properly. Details follow below.
+This repository contains a split version of the Roman-Urdu Parallel Dataset (Roman-Urdu-Parl) structured specifically to facilitate fair evaluation in machine transliteration tasks between Urdu and Roman-Urdu. 
+The Roman-Urdu language lacks standard orthography, leading to a wide range of transliteration variations for the same Urdu sentence. 
+This dataset addresses the need for non-overlapping train, test, and validation sets, mitigating data leakage that could otherwise inflate evaluation metrics.
+
+
+## Original Dataset Overview
+The original Roman-Urdu-Parl dataset consists of 6,365,808 rows, featuring parallel sentences in Urdu and Roman-Urdu. 
+These numbers can be replicated using the script at: scripts/check_stats.py
+The unique characteristics of the original dataset are as follows:
+
+- Unique Urdu sentences: 1,087,220
+- Unique Roman-Urdu sentences: 3,999,102
+- Rows where both sentences match: 167
+- Rows where both sentences differ: 6,365,641
+- Urdu sentences appearing only once: 90,637
+- Roman-Urdu sentences appearing only once: 3,165,765
+- Unique pairs of Urdu and Roman-Urdu sentences: 4,003,784
+- Short sentences (fewer than 3 words): 2,321
+
+## Motivation for a Structured Splitting Approach
+### Summary
+In the original dataset, variations in Roman-Urdu transliterations of the same Urdu sentence pose a risk of data leakage if randomly split into training, validation, and test sets.
+Random splits may cause the same Urdu sentence (or its Roman-Urdu variations) to appear in multiple sets, leading the model to "memorize" rather than generalize transliteration patterns.
+This structured split addresses the issue by ensuring unique sets with no overlap between training, validation, and test sets, thus promoting generalization.
+The script to split the dataset is at : splitting_rup_data.py
+
+### Detailed Motivation
+The Roman-Urdu language is an informal, non-standardized way of writing Urdu using the Roman alphabet, which allows for considerable variation in transliteration. 
+Different speakers may transliterate the same Urdu sentence in numerous ways, leading to a high degree of variability in Roman-Urdu spellings. 
+For instance, words like “کتاب” in Urdu can be written in Roman-Urdu as “kitaab,” “kitab,” or “kittab,” depending on the writer’s style and regional dialect influences.
+
+The original Roman-Urdu Parallel (Roman-Urdu-Parl) dataset takes advantage of this variability to create a large corpus of 6.365 million parallel sentences by pairing 1.1 million core Urdu sentences with multiple Roman-Urdu transliterations. 
+This variability-rich approach is invaluable for developing robust transliteration models. 
+However, this very characteristic introduces significant challenges for data splitting and evaluation, especially if the goal is to build a model capable of generalizing rather than memorizing specific transliterations.
+
+### Issues with Random Splitting
+A typical random splitting approach might divide the dataset into training, validation, and test sets without accounting for sentence variability. 
+This could lead to the following issues:
+
+1. Overlap of Sentence Variations Across Sets:
+Given the substantial transliteration variability, random splitting is likely to place different Roman-Urdu variations of the same Urdu sentence in multiple sets (e.g., training and test). As a result:
+a. Data Leakage: The model may encounter different transliterations of the same sentence across training and evaluation sets, effectively "seeing" a portion of the test or validation data during training. This exposure creates data leakage, enabling the model to memorize specific transliteration patterns rather than learning to generalize.
+b. Inflated Evaluation Scores: Due to data leakage, the model’s evaluation metrics—such as BLEU scores—could be artificially inflated. These metrics would then fail to reflect the model's true performance on genuinely unseen data, compromising the reliability of model assessments.
+
+2. Challenges in Model Generalization:
+If the same Urdu sentence (with different transliterations) appears in both training and evaluation sets, the model risks overfitting to common patterns rather than developing a nuanced understanding of transliteration rules.
+The model's performance on genuinely novel sentence structures and transliteration styles is therefore likely to be less reliable.
+
+### Importance of a Structured Split
+To address these issues, a structured data split is essential. 
+By creating a split that ensures no Urdu sentence and its variations appear in more than one set (training, validation, or test).
+
+## Dataset Splitting Strategy
+To prevent data leakage and ensure a balanced evaluation, the dataset is split according to the following strategy:
+
+1. Unique Sentence Selection for Validation and Test Sets:
+  Validation Set: 1,000 unique Urdu sentences with only one variation in the whole data of 6.3 million.
+  Test Set: Another 1,000 unique Urdu sentences (also with one variation) excluding those in the validation set.
+
+2. Replicated Sentence Selection (2-10 Variations):
+  Validation Set: 2,000 Urdu sentences that have between 2 and 10 Roman-Urdu variations. All variations these 2000 urdu sentences are added in this.
+  Test Set: An additional 2,000 Urdu sentences with 2-10 variations, ensuring no overlap with validation.
+
+3. Training Set Composition:
+  All remaining sentences and their variations, excluding those selected for the validation and test sets, are included in the training set.
+
+4. Smaller Subsets for Efficient Evaluation:
+Smaller Validation and Test Sets: These subsets are created to speed up evaluations during model development, with each containing 3,000 sentences (unique and replicated).
+Its also ensured that only one sentence is selected out of all the variations of an urdu sentence.
+
+## Checking if Training Sentences Are Composed of Test Sentences or Their Repetitions
+To ensure robust model performance and prevent data leakage, we checked if any training sentences were composed entirely of repeated test(or validation) sentences or their fragments. 
+In the original dataset, some sentences were simply repetitions of shorter sentences (e.g., "A B C D" and "A B C D A B C D"), which could lead to overfitting if these patterns appeared across training and test sets. 
+A Python script was developed to identify and flag these cases, allowing us to remove or separate such repetitive sentences across the dataset splits. This approach helps the model learn genuine transliteration patterns and avoids artificially inflated evaluation scores, promoting better generalization to unseen data.
+The python script is at: scripts/check_substring.py
+with our new split dataset this count is zero.
+
+## Key Features of the Split
+
+- No Overlap Between Sets: Ensures that no Urdu sentence (or its variations) appears in more than one set, effectively preventing data leakage.
+- Variation Inclusion: The comprehensive test and validation sets include all variations of selected Urdu sentences, providing a robust evaluation of the model's ability to handle transliteration diversity.
+- Smaller Subsets for Rapid Testing: Allows for quick testing during model development while preserving dataset integrity.
+- Random Sampling with Fixed Seed: Reproducibility is ensured by using a fixed random state.
+- Balanced Evaluation: Incorporates both unique sentences and replicated sentences with multiple variations for a complete assessment.
+- Data Integrity Checks: Verifies that no Urdu sentences are shared between the sets, ensuring an accurate measure of generalization.
+
+## Citation 
+
+Original Dataset paper:
+
+@article{alam2022roman,
+  title={Roman-urdu-parl: Roman-urdu and urdu parallel corpus for urdu language understanding},
+  author={Alam, Mehreen and Hussain, Sibt Ul},
+  journal={Transactions on Asian and Low-Resource Language Information Processing},
+  volume={21},
+  number={1},
+  pages={1--20},
+  year={2022},
+  publisher={ACM New York, NY}
+}
+
+## Dataset Card Authors [optional]
+
+I wouldnt call myself the author of this dataset because its the work of the greats. I just had to work on this data, so I created the splits properly. 
+Still if you are interested then my name is Umer (you can contact me on linkedin, username: UmerTariq1)

original_data/data.csv

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

original_data/dataset_stats.md

@@ -0,0 +1,15 @@
+Number of rows: 6365808
+
+Number of unique Urdu sentences: 1087220
+Number of unique Roman-Urdu sentences: 3999102
+
+Number of rows where both column values are the same: 167
+Number of rows where both column values are different: 6365641
+
+Number of rows where the Urdu sentence appears only once in the dataset: 90637
+Number of rows where the Roman-Urdu sentence appears only once in the dataset: 3165765
+
+Number of rows where the combination occurs "only once" in the whole dataset: 3170561
+Number of unique pairs of Urdu and Roman-Urdu sentences: 4003784
+
+Number of sentences which are less than 3 words:  2321

original_data/roman-urdu.txt

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

original_data/splitting_strategy_rur_to_ur.md

@@ -0,0 +1,68 @@
+**Original Issue**: 
+
+The dataset comprises 6.365 million parallel sentences in Urdu and Roman-Urdu. Many Roman-Urdu sentences are just variations of the same Urdu sentence due to different transliteration styles. If we randomly split this dataset into training, validation, and test sets, there's a high chance that variations of the same Urdu sentence will appear in multiple sets. This overlap can lead to data leakage, causing the model to memorize specific sentence pairs rather than learning to generalize transliteration patterns. Consequently, evaluation metrics like BLEU scores may be artificially inflated, not accurately reflecting the model's true performance on unseen data.
+
+
+**Splitting Strategy**: 
+To address this issue, the dataset is split into training, validation, and test sets in a way that ensures no Urdu sentence (and its variations) appears in more than one set. The strategy involves grouping sentences by unique Urdu text and carefully selecting sentences based on the number of their variations.
+
+1. **Load and Preprocess the Data**
+
+Load the Dataset: Read the CSV file containing Urdu and Roman-Urdu sentence pairs into a Pandas DataFrame.
+Remove Missing Entries: Drop any rows where the 'Urdu text' is missing.
+Group by Urdu Sentences: Group the data by 'Urdu text' and aggregate all corresponding 'Roman-Urdu text' variations into lists.
+Count Variations: Add a 'count' column representing the number of Roman-Urdu variations for each Urdu sentence.
+
+2. **Select Unique Sentences for Validation and Test Sets**
+
+Validation Set:
+Select 1,000 Urdu sentences that occur only once in the dataset (i.e., sentences with a 'count' of 1).
+Include their corresponding Roman-Urdu text.
+Test Set:
+From the remaining Urdu sentences with a 'count' of 1 (excluding those in the validation set), select another 1,000 sentences.
+Include their corresponding Roman-Urdu text.
+
+3. **Select Replicated Sentences with Variations for Validation and Test Sets**
+
+Validation Set:
+Select 2,000 Urdu sentences that have between 2 and 10 Roman-Urdu variations (i.e., 'count' > 1 and 'count' ≤ 10).
+Include all variations of these Urdu sentences in the validation set.
+Test Set:
+From the remaining Urdu sentences with 2 to 10 variations (excluding those in the validation set), select another 2,000 sentences.
+Include all variations of these Urdu sentences in the test set.
+
+4. **Prepare the Training Set**
+
+Exclude Test and Validation Sentences:
+Remove all Urdu sentences (and their variations) present in the test and validation sets from the original dataset.
+Form the Training Set:
+The training set consists of all remaining Urdu sentences and their corresponding Roman-Urdu variations not included in the test or validation sets.
+
+5. **Create Smaller Subsets for Quick Evaluation**
+
+Purpose: Facilitate faster testing and validation during model development.
+Validation Subset:
+From the unique Urdu sentences in the validation set, randomly select 1,000 sentences (they only have one variation).
+From the replicated Urdu sentences in the validation set, for each Urdu sentence, randomly select only one Roman-Urdu variation.
+Combine these to form a smaller validation set of 3,000 sentences.
+Test Subset:
+Repeat the same process for the test set to create a smaller test set of 3,000 sentences.
+
+
+**Key Points**:
+- No Overlap Between Sets: By excluding any Urdu sentences used in the test and validation sets from the training set, the strategy ensures no overlap, preventing data leakage.
+
+- Inclusion of All Variations: The large test and validation sets include all variations of selected Urdu sentences to thoroughly evaluate the model's ability to handle different transliterations.
+
+- Smaller Subsets for Efficiency: Smaller test and validation sets contain only one variation per Urdu sentence, allowing for quicker evaluations during model development without compromising the integrity of the results.
+
+- Random Sampling with Fixed Seed: A fixed random_state (e.g., 42) is used in all random sampling steps to ensure reproducibility of the data splits.
+
+- Balanced Evaluation: The strategy includes both unique sentences and those with multiple variations, providing a comprehensive evaluation of the model's performance across different levels of sentence frequency and complexity.
+
+- Data Integrity Checks: After splitting, the sizes of the datasets are verified, and checks are performed to confirm that no Urdu sentences are shared between the training, validation, and test sets.
+
+- Generalization Focus:By ensuring the model does not see any test or validation sentences during training, the evaluation metrics will accurately reflect the model's ability to generalize to unseen data.
+
+- We also tested for checked for if the training sentences are made up entirely of (test sentences or their repetitions) and found that there were no matches. (file: Transliterate/RUP/finetuning/scripts/one_time_usage/filter_uniqueurdu_data.py)
+

original_data/urdu.txt

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

scripts/check_stats.py

@@ -0,0 +1,56 @@
+import pandas as pd
+
+# File path to the input CSV file
+input_file_path = '../original_data/data.csv'
+# Output file path
+output_file_path = 'top_50_urdu.json'
+
+# Load the CSV file into a Pandas DataFrame
+df = pd.read_csv(input_file_path, encoding='utf-8')
+
+
+# count the number of rows
+num_rows = df.shape[0]
+print(f"Number of rows: {num_rows}")
+
+# Count the number of rows where both column values are the same
+same_values_count = df[df['Urdu text'] == df['Roman-Urdu text']].shape[0]
+print(f"Number of rows where both column values are the same: {same_values_count}")
+
+# count the number of rows where both column values are different
+different_values_count = df[df['Urdu text'] != df['Roman-Urdu text']].shape[0]
+print(f"Number of rows where both column values are different: {different_values_count}")
+
+# count the number of unique Urdu sentences
+unique_urdu_sentences = df['Urdu text'].nunique()
+print(f"Number of unique Urdu sentences: {unique_urdu_sentences}")
+
+# count the number of unique Roman-Urdu sentences
+unique_roman_urdu_sentences = df['Roman-Urdu text'].nunique()
+print(f"Number of unique Roman-Urdu sentences: {unique_roman_urdu_sentences}")
+
+# count the number of rows where the Urdu and Roman-Urdu sentences do not appear anywhere else together
+unique_pairs = df.groupby(['Urdu text', 'Roman-Urdu text']).size().reset_index(name='count')
+unique_pairs = unique_pairs[unique_pairs['count'] == 1].shape[0]
+print(f"Number of rows where the combination occurs only once in the whole dataset: {unique_pairs}")
+
+# count the number of unique pairs of Urdu and Roman-Urdu sentences
+unique_pairs = df.drop_duplicates().shape[0]
+print(f"Number of unique pairs of Urdu and Roman-Urdu sentences: {unique_pairs}")
+
+
+# count the number of rows where the Urdu sentence appears only once in the dataset
+urdu_sentence_counts = df['Urdu text'].value_counts()
+urdu_sentence_counts = urdu_sentence_counts[urdu_sentence_counts == 1].shape[0]
+print(f"Number of rows where the Urdu sentence appears only once in the dataset: {urdu_sentence_counts}")
+
+# count the number of rows where the Roman-Urdu sentence appears only once in the dataset
+roman_urdu_sentence_counts = df['Roman-Urdu text'].value_counts()
+roman_urdu_sentence_counts = roman_urdu_sentence_counts[roman_urdu_sentence_counts == 1].shape[0]
+print(f"Number of rows where the Roman-Urdu sentence appears only once in the dataset: {roman_urdu_sentence_counts}")
+
+
+# count the number of where the urdu sentences appear more than once but less than 11 times in the whole dataset
+urdu_sentence_counts = df['Urdu text'].value_counts()
+urdu_sentence_counts = urdu_sentence_counts[(urdu_sentence_counts > 1) & (urdu_sentence_counts <= 10)].shape[0]
+print(f"Number of rows where the Urdu sentence appears more than once but less than 11 times in the whole dataset: {urdu_sentence_counts}")

scripts/check_substring.py

@@ -0,0 +1,93 @@
+
+
+# Check if the training sentences are made up entirely of (test sentences or their repetitions)
+
+# Observation : Some of the sentences in original dataset comprised of other sentences in the dataset
+    # For example, One sentence would be "A B C D" and another sentence would be "A B C D A B C D"
+    # This is not a good thing as the model can easily overfit on the training data and 
+    # if the other sentence thats being repeated is in the test set, the model will perform very well on the test set but not on the real world data
+
+import pandas as pd
+import ahocorasick
+from tqdm import tqdm
+import json
+
+# File paths
+training_set_path = '../train_set.csv'
+test_set_path = '../small_validation_set.csv'
+
+print("Loading the CSV files...")
+# Load the CSV files into Pandas DataFrames
+test_set = pd.read_csv(test_set_path, encoding='utf-8')
+training_set = pd.read_csv(training_set_path, encoding='utf-8')
+
+print("CSV files loaded successfully.")
+
+# Prepare the test sentences
+test_sentences = test_set['Urdu text'].dropna()
+# Remove extra spaces and standardize
+test_sentences = test_sentences.apply(lambda x: ' '.join(x.strip().split()))
+# Skip sentences with only one word if desired
+test_sentences = test_sentences[test_sentences.str.split().str.len() > 1].unique()
+test_sentences_set = set(test_sentences)
+
+print(f"Number of test sentences: {len(test_sentences_set)}")
+
+# Build the Aho-Corasick automaton
+print("Building the Aho-Corasick automaton with test sentences...")
+A = ahocorasick.Automaton()
+
+for idx, test_sentence in enumerate(test_sentences):
+    A.add_word(test_sentence, (idx, test_sentence))
+
+A.make_automaton()
+print("Automaton built successfully.")
+
+# Initialize matches dictionary
+matches = {}
+
+print("Processing training sentences...")
+training_sentences = training_set['Urdu text'].dropna()
+# Remove extra spaces and standardize
+training_sentences = training_sentences.apply(lambda x: ' '.join(x.strip().split()))
+training_sentences = training_sentences.unique()
+
+for training_sentence in tqdm(training_sentences):
+    s = training_sentence
+    s_length = len(s)
+    matches_in_s = []
+    for end_index, (insert_order, test_sentence) in A.iter(s):
+        start_index = end_index - len(test_sentence) + 1
+        matches_in_s.append((start_index, end_index, test_sentence))
+    if not matches_in_s:
+        continue
+    # Sort matches by start_index
+    matches_in_s.sort(key=lambda x: x[0])
+    # Now check if matches cover the entire training sentence without gaps
+    # And all matches are of the same test sentence
+    covers_entire_sentence = True
+    current_index = 0
+    first_test_sentence = matches_in_s[0][2]
+    all_same_test_sentence = True
+    for start_index, end_index, test_sentence in matches_in_s:
+        if start_index != current_index:
+            covers_entire_sentence = False
+            break
+        if test_sentence != first_test_sentence:
+            all_same_test_sentence = False
+            break
+        current_index = end_index + 1
+    if covers_entire_sentence and current_index == s_length and all_same_test_sentence:
+        # Training sentence is made up entirely of repetitions of test_sentence
+        if test_sentence not in matches:
+            matches[test_sentence] = []
+        matches[test_sentence].append(s)
+print("Processing completed.")
+print("Number of matches: ", sum(len(v) for v in matches.values()))
+
+# Optionally, save matches to a JSON file
+output_file_path = '/netscratch/butt/Transliterate/RUP/finetuning/scripts/one_time_usage/test_training_matches.json'
+with open(output_file_path, 'w', encoding='utf-8') as json_file:
+    json.dump(matches, json_file, ensure_ascii=False, indent=4)
+
+print(f"Matches have been written to {output_file_path}")

scripts/splitting_rup_data.py

@@ -0,0 +1,109 @@
+# bash /home/butt/run_docker_cpu.sh python splitting_rup_data.py 
+
+import pandas as pd
+import numpy as np
+
+# File path to the input CSV file
+input_file_path = '../original_data/data.csv'
+# Output file paths for training, test, and validation sets
+base_path = "."
+
+train_output_path = base_path + 'train_set.csv'
+test_output_path = base_path + 'test_set.csv'
+validation_output_path = base_path + 'validation_set.csv'
+small_test_output_path = base_path + 'small_test_set.csv'
+small_validation_output_path = base_path + 'small_validation_set.csv'
+
+NUMBER_OF_UNIQUE_SENTENCES = 1500
+NUMBER_OF_REPLICATED_SENTENCES = 3000
+REPLICATION_RATE = 10
+
+# Load the CSV file into a Pandas DataFrame
+df = pd.read_csv(input_file_path, encoding='utf-8')
+
+# Drop rows where 'Urdu text' is NaN
+df = df.dropna(subset=['Urdu text'])
+
+# Group by 'Urdu text' and aggregate the corresponding 'Roman-Urdu text'
+grouped = df.groupby('Urdu text')['Roman-Urdu text'].apply(list).reset_index()
+
+# Add a 'count' column to store the number of occurrences
+grouped['count'] = grouped['Roman-Urdu text'].apply(len)
+
+# Select NUMBER_OF_UNIQUE_SENTENCES least occurring groupbys (unique sentences without replication in the dataset) for validation
+unique_sentences_val = grouped[grouped['count'] == 1].sample(n=NUMBER_OF_UNIQUE_SENTENCES, random_state=42)
+unique_sentences_val = unique_sentences_val.explode('Roman-Urdu text')  # Convert list to individual rows
+
+# select NUMBER_OF_UNIQUE_SENTENCES least occuring groupbys for test but they should not be in validation set (unique_sentences_val)
+unique_sentences_test = grouped[grouped['count'] == 1]
+unique_sentences_test = unique_sentences_test[~unique_sentences_test['Urdu text'].isin(unique_sentences_val['Urdu text'])]
+unique_sentences_test = unique_sentences_test.sample(n=NUMBER_OF_UNIQUE_SENTENCES, random_state=42)
+unique_sentences_test = unique_sentences_test.explode('Roman-Urdu text')  # Convert list to individual rows
+
+# variables replicated are for whole test/val sets and one_replicated are for small test/val sets
+
+# Select NUMBER_OF_REPLICATED_SENTENCES groupbys from sentences that appear less than or equal to REPLICATION_RATE times
+replicated_sentences_val = grouped[(grouped['count'] <= REPLICATION_RATE) & (grouped['count'] > 1)].sample(n=NUMBER_OF_REPLICATED_SENTENCES, random_state=42)
+
+# do the same but for test set and they should not be in validation set
+replicated_sentences_test = grouped[(grouped['count'] <= REPLICATION_RATE) & (grouped['count'] > 1)]
+replicated_sentences_test = replicated_sentences_test[~replicated_sentences_test['Urdu text'].isin(replicated_sentences_val['Urdu text'])]
+replicated_sentences_test = replicated_sentences_test.sample(n=NUMBER_OF_REPLICATED_SENTENCES, random_state=42)
+
+# select any 1 sentence from each group of the replicated sentences
+one_replicated_sentences_val = replicated_sentences_val.groupby('Urdu text').apply(lambda x: x.sample(1, random_state=42)).reset_index(drop=True)
+# do the same but for test set
+one_replicated_sentences_test = replicated_sentences_test.groupby('Urdu text').apply(lambda x: x.sample(1, random_state=42)).reset_index(drop=True)
+
+# explode both the replicated and one_replicated
+replicated_sentences_val = replicated_sentences_val.explode('Roman-Urdu text')
+one_replicated_sentences_val = one_replicated_sentences_val.explode('Roman-Urdu text')
+
+replicated_sentences_test = replicated_sentences_test.explode('Roman-Urdu text')
+one_replicated_sentences_test = one_replicated_sentences_test.explode('Roman-Urdu text')
+
+# Prepare the test and validation sets
+test_set = pd.concat([unique_sentences_test, replicated_sentences_test]).reset_index(drop=True)
+validation_set = pd.concat([unique_sentences_val, replicated_sentences_val]).reset_index(drop=True)
+
+# create smaller test and validation sets
+# subset NUMBER_OF_UNIQUE_SENTENCES from unique test
+small_unique_sentences_test = unique_sentences_test.sample(n=NUMBER_OF_UNIQUE_SENTENCES, random_state=42)
+# subset NUMBER_OF_UNIQUE_SENTENCES from unique validation
+small_unique_sentences_val = unique_sentences_val.sample(n=NUMBER_OF_UNIQUE_SENTENCES, random_state=42)
+
+# subset NUMBER_OF_REPLICATED_SENTENCES from replicated test
+small_replicated_sentences_test = replicated_sentences_test.sample(n=NUMBER_OF_REPLICATED_SENTENCES, random_state=42)
+# subset NUMBER_OF_REPLICATED_SENTENCES from replicated validation
+small_replicated_sentences_val = replicated_sentences_val.sample(n=NUMBER_OF_REPLICATED_SENTENCES, random_state=42)
+
+
+# explode all the small sets
+small_unique_sentences_test = small_unique_sentences_test.explode('Roman-Urdu text')
+small_unique_sentences_val = small_unique_sentences_val.explode('Roman-Urdu text')
+small_replicated_sentences_test = small_replicated_sentences_test.explode('Roman-Urdu text')
+small_replicated_sentences_val = small_replicated_sentences_val.explode('Roman-Urdu text')
+
+# combine the small sets
+small_test_set = pd.concat([small_unique_sentences_test, small_replicated_sentences_test]).reset_index(drop=True)
+small_validation_set = pd.concat([small_unique_sentences_val, small_replicated_sentences_val]).reset_index(drop=True)
+
+# Prepare the training set by excluding the test and validation sets from the original DataFrame
+# training set should be the whole data except fpr test_set and validation_set
+training_set = df[~df['Urdu text'].isin(test_set['Urdu text']) & ~df['Urdu text'].isin(validation_set['Urdu text'])]
+
+
+# Save only 'Urdu text' and 'Roman-Urdu text' columns to CSV files
+training_set[['Urdu text', 'Roman-Urdu text']].to_csv(train_output_path, index=False, encoding='utf-8')
+test_set[['Urdu text', 'Roman-Urdu text']].to_csv(test_output_path, index=False, encoding='utf-8')
+validation_set[['Urdu text', 'Roman-Urdu text']].to_csv(validation_output_path, index=False, encoding='utf-8')
+small_test_set[['Urdu text', 'Roman-Urdu text']].to_csv(small_test_output_path, index=False, encoding='utf-8')
+small_validation_set[['Urdu text', 'Roman-Urdu text']].to_csv(small_validation_output_path, index=False, encoding='utf-8')
+
+print(f"Training, test, validation, and smaller subsets have been saved to respective CSV files.")
+# Print the number of rows in each file
+print(f"Number of rows in training set: {len(training_set)}")
+print(f"Number of rows in test set: {len(test_set)}")
+print(f"Number of rows in validation set: {len(validation_set)}")
+print(f"Number of rows in small test set: {len(small_test_set)}")
+print(f"Number of rows in small validation set: {len(small_validation_set)}")

small_test_set.csv

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

small_validation_set.csv

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

splitting_strategy_rur_to_ur.md

@@ -0,0 +1,68 @@
+**Original Issue**: 
+
+The dataset comprises 6.365 million parallel sentences in Urdu and Roman-Urdu. Many Roman-Urdu sentences are just variations of the same Urdu sentence due to different transliteration styles. If we randomly split this dataset into training, validation, and test sets, there's a high chance that variations of the same Urdu sentence will appear in multiple sets. This overlap can lead to data leakage, causing the model to memorize specific sentence pairs rather than learning to generalize transliteration patterns. Consequently, evaluation metrics like BLEU scores may be artificially inflated, not accurately reflecting the model's true performance on unseen data.
+
+
+**Splitting Strategy**: 
+To address this issue, the dataset is split into training, validation, and test sets in a way that ensures no Urdu sentence (and its variations) appears in more than one set. The strategy involves grouping sentences by unique Urdu text and carefully selecting sentences based on the number of their variations.
+
+1. **Load and Preprocess the Data**
+
+Load the Dataset: Read the CSV file containing Urdu and Roman-Urdu sentence pairs into a Pandas DataFrame.
+Remove Missing Entries: Drop any rows where the 'Urdu text' is missing.
+Group by Urdu Sentences: Group the data by 'Urdu text' and aggregate all corresponding 'Roman-Urdu text' variations into lists.
+Count Variations: Add a 'count' column representing the number of Roman-Urdu variations for each Urdu sentence.
+
+2. **Select Unique Sentences for Validation and Test Sets**
+
+Validation Set:
+Select 1,000 Urdu sentences that occur only once in the dataset (i.e., sentences with a 'count' of 1).
+Include their corresponding Roman-Urdu text.
+Test Set:
+From the remaining Urdu sentences with a 'count' of 1 (excluding those in the validation set), select another 1,000 sentences.
+Include their corresponding Roman-Urdu text.
+
+3. **Select Replicated Sentences with Variations for Validation and Test Sets**
+
+Validation Set:
+Select 2,000 Urdu sentences that have between 2 and 10 Roman-Urdu variations (i.e., 'count' > 1 and 'count' ≤ 10).
+Include all variations of these Urdu sentences in the validation set.
+Test Set:
+From the remaining Urdu sentences with 2 to 10 variations (excluding those in the validation set), select another 2,000 sentences.
+Include all variations of these Urdu sentences in the test set.
+
+4. **Prepare the Training Set**
+
+Exclude Test and Validation Sentences:
+Remove all Urdu sentences (and their variations) present in the test and validation sets from the original dataset.
+Form the Training Set:
+The training set consists of all remaining Urdu sentences and their corresponding Roman-Urdu variations not included in the test or validation sets.
+
+5. **Create Smaller Subsets for Quick Evaluation**
+
+Purpose: Facilitate faster testing and validation during model development.
+Validation Subset:
+From the unique Urdu sentences in the validation set, randomly select 1,000 sentences (they only have one variation).
+From the replicated Urdu sentences in the validation set, for each Urdu sentence, randomly select only one Roman-Urdu variation.
+Combine these to form a smaller validation set of 3,000 sentences.
+Test Subset:
+Repeat the same process for the test set to create a smaller test set of 3,000 sentences.
+
+
+**Key Points**:
+- No Overlap Between Sets: By excluding any Urdu sentences used in the test and validation sets from the training set, the strategy ensures no overlap, preventing data leakage.
+
+- Inclusion of All Variations: The large test and validation sets include all variations of selected Urdu sentences to thoroughly evaluate the model's ability to handle different transliterations.
+
+- Smaller Subsets for Efficiency: Smaller test and validation sets contain only one variation per Urdu sentence, allowing for quicker evaluations during model development without compromising the integrity of the results.
+
+- Random Sampling with Fixed Seed: A fixed random_state (e.g., 42) is used in all random sampling steps to ensure reproducibility of the data splits.
+
+- Balanced Evaluation: The strategy includes both unique sentences and those with multiple variations, providing a comprehensive evaluation of the model's performance across different levels of sentence frequency and complexity.
+
+- Data Integrity Checks: After splitting, the sizes of the datasets are verified, and checks are performed to confirm that no Urdu sentences are shared between the training, validation, and test sets.
+
+- Generalization Focus:By ensuring the model does not see any test or validation sentences during training, the evaluation metrics will accurately reflect the model's ability to generalize to unseen data.
+
+- We also tested for checked for if the training sentences are made up entirely of (test sentences or their repetitions) and found that there were no matches. (file: Transliterate/RUP/finetuning/scripts/one_time_usage/filter_uniqueurdu_data.py)
+

test_set.csv

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

train_set.csv

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

validation_set.csv

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