Add Roman-Urdu-Parl-split dataset files with LFS

.gitattributes

@@ -1,58 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.txt filter=lfs diff=lfs merge=lfs -text

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