add scripts to reproduce

create_data.py

@@ -0,0 +1,122 @@
+import time
+import os
+from datasets import load_dataset
+import pickle
+
+
+# Define a helper function to load datasets with retry mechanism
+def load_dataset_with_retries(dataset_name, *args, retries=3, wait=5, **kwargs):
+    for attempt in range(retries):
+        try:
+            return load_dataset(dataset_name, *args, **kwargs)
+        except Exception as e:
+            print(f"Attempt {attempt + 1} failed for {dataset_name}. Error: {e}")
+            if attempt < retries - 1:
+                time.sleep(wait)
+            else:
+                raise
+
+
+# Checkpoint file to save progress
+checkpoint_file = 'tunisian_data_checkpoint.txt'
+dataset_count_path = 'data_count.pkl'
+
+# Load progress if checkpoint exists
+if os.path.exists(checkpoint_file):
+    with open(checkpoint_file, 'r') as f:
+        final_data = eval(f.read())
+else:
+    final_data = []
+
+if os.path.exists(dataset_count_path):
+    # Loading the variable back
+    with open(dataset_count_path, 'rb') as f:
+        loaded_data = pickle.load(f)
+        datasets_completed = loaded_data['datasets_completed']
+else:
+    datasets_completed = 0
+
+
+# Helper function to save progress to a checkpoint file
+def save_checkpoint(data):
+    with open(checkpoint_file, 'w') as f:
+        f.write(str(data))
+
+
+def save_datasets_completed(num):
+    # Saving the variable to a file
+    with open(dataset_count_path, 'wb') as f:
+        pickle.dump({'datasets_completed': num}, f)
+
+
+# Load and process datasets
+try:
+    if datasets_completed < 1:
+        ds_xp3x = load_dataset_with_retries("Muennighoff/xP3x", "aeb_Arab", trust_remote_code=True)
+        final_data.extend(list(sentence['targets'] for sentence in ds_xp3x['train']))
+        save_checkpoint(final_data)
+        datasets_completed += 1
+
+    if datasets_completed < 2:
+        ds_glotcc = load_dataset_with_retries("cis-lmu/glotcc-v1", name="aeb-Arab", split="train")
+        final_data.extend(list(sentence['content'] for sentence in ds_glotcc))
+        save_checkpoint(final_data)
+        datasets_completed += 1
+
+    if datasets_completed < 3:
+        ds_flores = load_dataset_with_retries('facebook/flores', 'aeb_Arab')
+        final_data.extend(list(sentence['sentence'] for sentence in ds_flores['dev']))
+        final_data.extend(list(sentence['sentence'] for sentence in ds_flores['devtest']))
+        save_checkpoint(final_data)
+        datasets_completed += 1
+
+    if datasets_completed < 4:
+        ds_glotstory = load_dataset_with_retries('cis-lmu/GlotStoryBook', 'default', split='train')
+        glotstory_sentences = [sentence for sentence in ds_glotstory if sentence["Language"] == 'aeb']
+        final_data.extend(glotstory_sentences)
+        save_checkpoint(final_data)
+        datasets_completed += 1
+
+    if datasets_completed < 5:
+        ds_sib200 = load_dataset_with_retries('Davlan/sib200', 'aeb_Arab')
+        final_data.extend(list(sentence['text'] for sentence in ds_sib200['train']))
+        final_data.extend(list(sentence['text'] for sentence in ds_sib200['validation']))
+        final_data.extend(list(sentence['text'] for sentence in ds_sib200['test']))
+        save_checkpoint(final_data)
+        datasets_completed += 1
+
+    if datasets_completed < 6:
+        ds_xsimplus = load_dataset_with_retries("jaygala24/xsimplusplus", "aeb_Arab")
+        final_data.extend(list(sentence['query'] for sentence in ds_xsimplus['dev']))
+        final_data.extend(list(sentence['query'] for sentence in ds_xsimplus['devtest']))
+        save_checkpoint(final_data)
+        datasets_completed += 1
+
+    if datasets_completed < 7:
+        ds_gentai = load_dataset_with_retries("gentaiscool/bitext_sib200_miners", "eng_Latn-aeb_Arab")
+        final_data.extend(list(sentence['sentence2'] for sentence in ds_gentai['train']))
+        save_checkpoint(final_data)
+        datasets_completed += 1
+
+    if datasets_completed < 8:
+        dataset_reddit = load_dataset_with_retries('dataverse-scraping/reddit_dataset_219', split='train',
+                                                   streaming=True)
+
+
+        def filter_function(example):
+            return example['communityName'] == 'r/Tunisia'  # Replace with your filter condition
+
+
+        filtered_dataset = dataset_reddit.filter(filter_function)
+        final_data.extend(list(sentence['text'] for sentence in filtered_dataset))
+        save_checkpoint(final_data)
+        datasets_completed += 1
+
+    # Final save to a text file
+    with open('tunisian_data.txt', 'w') as f:
+        for line in final_data:
+            f.write(f"{line}\n")
+
+except Exception as e:
+    print(f"An error occurred: {e}. Progress saved.")
+    save_checkpoint(final_data)

preprocess.py

@@ -0,0 +1,103 @@
+import re
+from collections import Counter
+
+import pandas as pd
+from datasketch import MinHash, MinHashLSH
+from lingua import Language, LanguageDetectorBuilder
+
+# Initialize variables for statistics
+word_count = Counter()
+longest_sentence = ""
+shortest_sentence = None
+total_sentences = 0
+all_sentences = []
+
+
+def tokenize(text):
+    """
+    Clean and split text into words.
+    """
+    # Remove punctuation and split by whitespace
+    words = re.findall(r'\b\w+\b', text.lower())
+    return words
+
+
+# Open the file and process line by line
+with open('tunisian_data.txt', 'r') as file:
+    for line in file:
+        # Strip leading/trailing whitespace
+        line = line.strip()
+
+        # Skip empty lines
+        if not line:
+            continue
+
+        # Split the line into sentences (using '.', '!', or '?' as delimiters)
+        sentences = re.split(r'[.!?]', line)
+
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if sentence:
+                all_sentences.append(sentence)
+                total_sentences += 1
+
+                # Update longest and shortest sentences
+                if len(sentence) > len(longest_sentence):
+                    longest_sentence = sentence
+                if shortest_sentence is None or len(sentence) < len(shortest_sentence):
+                    shortest_sentence = sentence
+
+                # Tokenize and count words
+                words = tokenize(sentence)
+                word_count.update(words)
+
+# Get the most common words
+most_common_words = word_count.most_common(10)
+print(f"Most Common Words: {most_common_words}")
+
+
+def get_minhash(text, num_perm=128):
+    """
+    Generate a MinHash for a given text.
+    """
+    tokens = set(text.split())
+    m = MinHash(num_perm=num_perm)
+    for token in tokens:
+        m.update(token.encode('utf8'))
+    return m
+
+
+def minhash_deduplication(docs, threshold=0.8, num_perm=128):
+    """
+    Remove near-duplicate documents using MinHash LSH.
+    """
+    lsh = MinHashLSH(threshold=threshold, num_perm=num_perm)
+    unique_docs = []
+
+    for i, doc in enumerate(docs):
+        m = get_minhash(doc, num_perm=num_perm)
+        if not lsh.query(m):  # Check if the document is a near duplicate
+            lsh.insert(i, m)
+            unique_docs.append(doc)
+
+    return unique_docs
+
+
+unique_docs = minhash_deduplication(all_sentences, threshold=0.8)
+print(f"Number of unique documents: {len(unique_docs)}")
+
+# Language detection
+detector = LanguageDetectorBuilder.from_languages(*Language.all()).build()
+labels = []
+cleaned_text = []
+
+for s in unique_docs:
+    l = detector.detect_language_of(s)
+    if not l:
+        print(f"Could not detect language for sentence: {s}")
+    else:
+        labels.append(l.name)
+        cleaned_text.append(s)
+
+# Create a DataFrame with the cleaned text
+df = pd.DataFrame({'text': cleaned_text})