added char_syl_ngram/

char_syl_ngram/__init__.py

@@ -0,0 +1,3 @@
+# __init__.py in char_syl_ngram directory
+from .char_syl_ngram import sylbreak, generate_ngrams, generate_char_ngrams, train_naive_bayes, detect_language_naive_bayes
+

char_syl_ngram/char_syl_ngram.py

@@ -0,0 +1,100 @@
+"""
+Approach: A language detection algorithm using a Naive Bayes classifier with n-gram models
+
+The n-gram model in this script is built by generating n-grams (either syllable or character-based) from a text corpus and computing their frequencies. Laplace smoothing is applied to these frequencies to account for n-grams not present in the training data, ensuring non-zero probabilities. For language detection, the script compares the n-grams of the input text against pre-computed language profiles, using a backoff strategy for missing n-grams, progressively reducing their length until a match is found. The detection calculates a score for each language by summing the logarithm of the probabilities of the text's n-grams according to the language profile. Finally, it normalizes these scores into a probability distribution, indicating the likelihood of the input text belonging to each language.
+
+Language profile format: JSON
+
+Written by Ye Kyaw Thu, LU Lab., Myanmar
+Last updated: 31 Jan 2024
+"""
+
+import os
+import sys
+import argparse
+import re
+from collections import defaultdict, Counter
+from math import log
+
+def sylbreak(text):
+    myConsonant = r"က-အၵၶꧠၚၸꩡၡၛၺꧣၻၼၽၾၿၥဿႁၜၝၯၦဢဧဨဩ"
+    enChar = r"a-zA-Z0-9"
+    ssSymbol = r"္"
+    aThat = r"်"
+    otherChar = r"ဣဤဥဦဧဩဪဿ၌၍၎၏၀-၉႐-႙၊။!-\/:-\@\[-`’“”{-~\s…"
+
+    pattern = fr"((?<!{ssSymbol})[{myConsonant}](?![{aThat}{ssSymbol}])|[{enChar}{otherChar}])"
+
+    # Using re.sub to insert a space before every matched pattern
+    result = re.sub(pattern, r' \1', text)
+    #return result.strip()  # Removing leading and trailing spaces
+    return result.split()
+
+def generate_ngrams(tokens, n):
+    return [' '.join(tokens[i:i+n]) for i in range(len(tokens) - n + 1)]
+
+def generate_char_ngrams(text, n):
+    return [text[i:i+n] for i in range(len(text) - n + 1)]
+
+def train_naive_bayes(corpus, n=3, k=0.01, use_syllables=True):
+    if use_syllables:
+        tokens = sylbreak(corpus)
+        ngrams = generate_ngrams(tokens, n)
+    else:
+        ngrams = generate_char_ngrams(corpus, n)
+
+    ngram_freqs = Counter(ngrams)
+    total_ngrams = len(ngrams)
+    vocab_size = len(ngram_freqs)
+    probabilities = {ngram: (count + k) / (total_ngrams + vocab_size * k) for ngram, count in ngram_freqs.items()}
+    return probabilities
+
+def backoff_strategy(ngram, profile):
+    #if ngram not in profile:
+    #    print(f"N-gram not found: {ngram}")
+    tokens = ngram.split()
+    while tokens and ' '.join(tokens) not in profile:
+        tokens = tokens[1:]
+    ngram = ' '.join(tokens)
+    if not ngram:
+        return 1e-5  # Instead of 1 / len(profile)
+    return profile.get(ngram)
+
+def detect_language_naive_bayes(text, profiles_folder, n=3, use_syllables=True, verbose=False):
+    profiles = {}
+    for profile_file in os.listdir(profiles_folder):
+        profile_path = os.path.join(profiles_folder, profile_file)
+        with open(profile_path, 'r', encoding='utf-8') as f:
+            profile_data = {}
+            for line_no, line in enumerate(f, 1):
+                parts = line.strip().split('\t')
+                if len(parts) != 2:
+                    if verbose:
+                        print(f"Warning: Malformed line #{line_no} in {profile_path}. Skipping.")
+                    continue
+                ngram, prob = parts
+                profile_data[ngram] = float(prob)
+            profiles[os.path.splitext(profile_file)[0]] = profile_data
+
+    scores = defaultdict(float)
+    if use_syllables:
+        tokens = sylbreak(text)
+        ngrams_text = Counter(generate_ngrams(tokens, n))
+    else:
+        ngrams_text = Counter(generate_char_ngrams(text, n))
+
+    for language, profile in profiles.items():
+        for ngram, count in ngrams_text.items():
+            prob = backoff_strategy(ngram, profile)
+            scores[language] += count * log(prob)
+
+    # Normalize scores
+    max_score = max(scores.values())
+    exp_scores = {lang: 2 ** (score - max_score) for lang, score in scores.items()}
+    total_score = sum(exp_scores.values())
+    probabilities = {language: score / total_score for language, score in exp_scores.items()}
+
+    return probabilities
+
+
+

char_syl_ngram/ref/language_detection.py

@@ -0,0 +1,128 @@
+"""
+
+ဒီဗားရှင်းက ngram profile မဆောက်ခင်မှာ အရင်ဆုံး syllable ဖြတ်လိုက်တယ်။ ပြီးမှ syllable ngram ဆောက်တာ။  
+
+"""
+
+import os
+import sys
+import argparse
+from collections import defaultdict, Counter
+from math import log
+import re
+
+def sylbreak(text):
+    myConsonant = r"က-အၵၶꧠၚၸꩡၡၛၺꧣၻၼၽၾၿၥဿႁၜၝၯၦဢဧဨဩ"
+    enChar = r"a-zA-Z0-9"
+    ssSymbol = r"္"
+    aThat = r"်"
+    otherChar = r"ဣဤဥဦဧဩဪဿ၌၍၎၏၀-၉႐-႙၊။!-\/:-\@\[-`’“”{-~\s…"
+
+    pattern = fr"((?<!{ssSymbol})[{myConsonant}](?![{aThat}{ssSymbol}])|[{enChar}{otherChar}])"
+    
+    # Using re.sub to insert a space before every matched pattern
+    result = re.sub(pattern, r' \1', text)
+    #return result.strip()  # Removing leading and trailing spaces
+    return result.split()
+
+
+def generate_ngrams(tokens, n):
+    return [' '.join(tokens[i:i+n]) for i in range(len(tokens) - n + 1)]
+
+
+def train_naive_bayes(corpus, n=3, k=0.01):
+    ngrams = generate_ngrams(corpus, n)
+    ngram_freqs = Counter(ngrams)
+    total_ngrams = len(ngrams)
+
+    # Convert counts to probabilities with refined Laplace smoothing
+    vocab_size = len(ngram_freqs)
+    probabilities = {ngram: (count + k) / (total_ngrams + vocab_size*k) for ngram, count in ngram_freqs.items()}
+
+    return probabilities
+
+def backoff_strategy(ngram, profile):
+    #if ngram not in profile:
+    #    print(f"N-gram not found: {ngram}")
+    tokens = ngram.split()
+    while tokens and ' '.join(tokens) not in profile:
+        tokens = tokens[1:]
+    ngram = ' '.join(tokens)
+    if not ngram:
+        return 1e-5  # Instead of 1 / len(profile)
+    return profile.get(ngram)
+
+def detect_language_naive_bayes(text, profiles_folder, n=3, verbose=False):
+    profiles = {}
+    for profile_file in os.listdir(profiles_folder):
+        profile_path = os.path.join(profiles_folder, profile_file)
+        with open(profile_path, 'r', encoding='utf-8') as f:
+            profile_data = {}
+            for line_no, line in enumerate(f, 1):
+                parts = line.strip().split('\t')
+                if len(parts) != 2:
+                    if verbose:
+                        print(f"Warning: Malformed line #{line_no} in {profile_path}. Skipping.")
+                    continue
+                ngram, prob = parts
+                profile_data[ngram] = float(prob)
+            profiles[os.path.splitext(profile_file)[0]] = profile_data
+
+    scores = defaultdict(float)
+    ngrams_text = Counter(generate_ngrams(text, n))
+    #print(list(ngrams_text.items())[:5])  # print first 5 n-grams of input text
+
+
+    for language, profile in profiles.items():
+        #print(language, list(profile.items())[:5])  # print first 5 n-grams for each language, 4debug
+
+        for ngram, count in ngrams_text.items():
+            prob = backoff_strategy(ngram, profile)
+            scores[language] += count * log(prob)
+
+    # Normalize scores
+    max_score = max(scores.values())
+    exp_scores = {lang: 2 ** (score - max_score) for lang, score in scores.items()}
+    total_score = sum(exp_scores.values())
+    probabilities = {language: score / total_score for language, score in exp_scores.items()}
+
+    return probabilities
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Naive Bayes based language detection and profile creation.')
+    parser.add_argument('-i', '--input', type=str, required=True, help='Input file path.')
+    parser.add_argument('-o', '--output', type=str, help='Output file path (only for profile creation).', default=None)
+    parser.add_argument('-c', '--create_profile', action='store_true', help='Flag to create profile.')
+    parser.add_argument('-d', '--detect', action='store_true', help='Flag to detect language.')
+    parser.add_argument('-p', '--profile_folder', type=str, help='Folder path containing language profiles (only for detection).', default=None)
+    parser.add_argument('-n', '--ngram', type=int, help='Maximum n-gram value (default: 3).', default=3)
+    parser.add_argument('-v', '--verbose', action='store_true', help='Display warning messages.')
+
+    args = parser.parse_args()
+
+    with open(args.input, 'r', encoding='utf-8') as file:
+        raw_text = file.read();
+        text = sylbreak(raw_text.replace(' ', ''))  # Removing spaces and then applying syllable breaking
+        
+
+    if args.create_profile:
+        profile = train_naive_bayes(text, args.ngram)
+        if args.output:
+            with open(args.output, 'w', encoding='utf-8') as file:
+                for ngram, prob in profile.items():
+                    file.write(f"{ngram}\t{prob}\n")
+        else:
+            for ngram, prob in profile.items():
+                sys.stdout.write(f"{ngram}\t{prob}\n")
+
+    elif args.detect:
+        if not args.profile_folder:
+            print("Please provide a profiles folder for detection using -p or --profile_folder!")
+            sys.exit(1)
+        probabilities = detect_language_naive_bayes(text, args.profile_folder, args.ngram, args.verbose)
+        for lang, prob in probabilities.items():
+            print(f"{lang}: {prob*100:.2f}%")
+
+    else:
+        print("Please choose an operation: create profile (-c) or detect language (-d).")
+