added shell scripts etc.

README.txt

@@ -0,0 +1,63 @@
+# For your information
+
+Written by Ye Kyaw Thu, LU Lab., Myanmar
+Last updated: 31 Jan 2024
+
+Filename: exp.sh
+This shell script builds all language profiles and performs detection. It demonstrates how to build and detect languages using all the detection approaches I have implemented.
+Note: Completing this process will take some time.
+
+## Approach: Character+Syllable Frequency
+
+build_profile_with_char_syl_freq.sh
+detect_with_char_syl_freq.sh
+
+## Approach: Character+Syllable Ngram with Bayes
+
+build_profile_with_char_syl_ngram.sh
+detect_with_char_syl_ngram.sh
+
+## Approach: Word2Vec, FastText Embedding
+
+build_profile_with_embeddings.sh
+detect_with_embedding.sh
+
+## Approach: FastText Classifier
+train_with_fasttext_classifier.sh
+detect_with_fasttext.sh
+
+## Approach: Neural Network Modeling
+
+train_with_nerual.sh
+detect_with_neural.sh
+
+## Folder Information
+
+(base) ye@lst-gpu-3090:~/exp/myNLP/lang_detect$ tree . -d -L 1
+.
+├── char_syl_freq
+├── char_syl_ngram
+├── data
+├── embedding
+├── fasttext_class
+├── log
+├── neural
+├── preprocess
+├── profile
+├── tmp
+└── tool
+
+11 directories
+
+Here,
+- The 'char_syl_freq/' folder contains the 'char_syl_freq' module.
+- The 'char_syl_ngram/' folder contains the 'char_syl_ngram' module.
+- The 'data/' folder holds the data used for building Myanmar language profiles and for detection.
+- The 'embedding/' folder includes modules for word embeddings (e.g., word2vec, fasttext).
+- The 'fasttext_class' folder contains the FastText classification module.
+- The 'log/' folder stores log files for building and detecting using all six approaches.
+- The 'neural/' folder contains the neural network-based language detection module.
+- The 'preprocess/' folder includes various preprocessing scripts.
+- The 'profile/' folder holds built language profiles for Bamar (Myanmar language), Beik, Dawei, Mon, Pao, Po Kayin, Rakhine, Sgaw Kayin, and Shan.
+
+

build_profile_with_char_syl_freq.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+# Define the base directory and the Python script
+BASE_DIR="$HOME/exp/myNLP/lang_detect"
+PYTHON_SCRIPT="$BASE_DIR/demo_usage.py"
+TEXT_DIR="$BASE_DIR/data/raw"  # Assuming you have raw text files for training
+PROFILE_DIR="$BASE_DIR/profile/char_syl_freq_profile"
+
+# Create the profile directory if it doesn't exist
+mkdir -p "$PROFILE_DIR"
+
+# Loop through each text file in the text_files directory
+for file in "$TEXT_DIR"/*.raw; do
+    # Extract the language name from the filename
+    filename=$(basename -- "$file")
+    language=${filename%%.*}
+
+    # Define the output profile filename
+    output_profile="$PROFILE_DIR/${language}_combined_profile.json"
+
+    # Run the Python script to create the profile
+    if python3 "$PYTHON_SCRIPT" --mode train --input "$file" --output "$output_profile" --approach char_syl_freq; then
+        echo "Created combined character and syllable language profile for $language."
+    else
+        echo "Error in creating profile for $language. Check the input file and script."
+        exit 1
+    fi
+done
+
+echo "All language profiles have been created."
+

build_profile_with_char_syl_ngram.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+# Define the base directory and the Python script
+BASE_DIR="$HOME/exp/myNLP/lang_detect/"
+PYTHON_SCRIPT="$BASE_DIR/demo_usage.py"
+TEXT_DIR="$BASE_DIR/data/raw"  # Assuming you have raw text files for training
+OUTPUT_BASE_DIR="$BASE_DIR/profile/"  # Base directory for output profiles
+
+# Define the n-gram values to iterate through
+NGRAM_VALUES=(3 4 5)
+
+# Loop through each n-gram value
+for ngram_value in "${NGRAM_VALUES[@]}"; do
+    # Create the output directory for this n-gram value
+    OUTPUT_DIR="$OUTPUT_BASE_DIR/${ngram_value}gram_profile"
+    mkdir -p "$OUTPUT_DIR"
+
+    # Loop through each text file in the text_files directory
+    for file in "$TEXT_DIR"/*.raw; do
+        # Extract the language name from the filename
+        filename=$(basename -- "$file")
+        language=${filename%%.*}
+
+        # Define the output profile filename based on n-gram value
+        output_profile="$OUTPUT_DIR/${language}.${ngram_value}gram"
+
+        # Run the Python script to create the profile
+        if python3 "$PYTHON_SCRIPT" --mode train --ngram "$ngram_value" --input "$file" --output "$output_profile" --approach char_syl_ngram; then
+            echo "Created ${ngram_value}-gram language profile for $language."
+        else
+            echo "Error in creating ${ngram_value}-gram profile for $language. Check the input file and script."
+            exit 1
+        fi
+    done
+done
+
+echo "All language profiles have been created."
+

build_profile_with_embeddings.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# Define the base directory and the Python script
+BASE_DIR="$HOME/exp/myNLP/lang_detect/"
+PYTHON_SCRIPT="$BASE_DIR/demo_usage.py"  # Replace with the name of your Python script
+SYL_SEG_DIR="$BASE_DIR/data/syl_seg"
+WORD2VEC_DIR="$BASE_DIR/profile/word2vec"
+FASTTEXT_DIR="$BASE_DIR/profile/fasttext"
+
+# Create directories for the models if they don't exist
+mkdir -p "$WORD2VEC_DIR"
+mkdir -p "$FASTTEXT_DIR"
+
+# Loop through each .syl file in the syl_seg directory
+for file in "$SYL_SEG_DIR"/*.syl; do
+    # Extract the language name from the filename
+    filename=$(basename -- "$file")
+    language=${filename%%.*}
+
+    # Define the output model filenames
+    word2vec_output="$WORD2VEC_DIR/${language}_word2vec.model"
+    fasttext_output="$FASTTEXT_DIR/${language}_fasttext.model"
+
+    # Train Word2Vec model
+    python3 "$PYTHON_SCRIPT" --mode train --approach word2vec_embedding --input "$file" --output "$word2vec_output"
+    echo "Word2Vec model for $language saved to $word2vec_output"
+
+    # Train FastText model
+    python3 "$PYTHON_SCRIPT" --mode train --approach fasttext_embedding --input "$file" --output "$fasttext_output"
+    echo "FastText model for $language saved to $fasttext_output"
+done
+
+echo "Training completed for all languages."
+

demo_usage.py

@@ -0,0 +1,232 @@
+"""
+Demo Usage of myZagar language detection library.
+Written by Ye Kyaw Thu, LU Lab., Myanmar
+Last updated: 31 Jan 2024
+
+Usage: python ./demo_usage.py --help
+"""
+
+
+import argparse
+import os
+import sys
+from collections import defaultdict, Counter
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+
+from char_syl_freq import create_frequency_profile, detect_language as detect_language_freq, save_profile as save_freq_profile, load_profiles as load_freq_profiles, break_syllables
+from char_syl_ngram import train_naive_bayes, detect_language_naive_bayes, sylbreak
+from embedding import train_embeddings, save_model as save_embed_model, load_model as load_embed_model, detect_language as detect_language_embed
+from fasttext_class import train_model as fasttext_class_train_model, test_model as fasttext_class_test_model, predict_language 
+from neural import load_data as load_neural_data, preprocess_data as neural_preprocess_data, build_model as build_neural_model, train_model as train_neural_model, save_model_and_artifacts, load_model_and_artifacts, detect_language as detect_language_neural 
+
+def main():
+    parser = argparse.ArgumentParser(description='Language detection based on character, n-gram frequency analysis, embeddings.')
+
+    # Add approach argument to select the approach
+    parser.add_argument('--approach', choices=['char_syl_freq', 'char_syl_ngram', 'word2vec_embedding', 'fasttext_embedding', 'fasttext_class', 'neural_network'], required=True, help='Select the approach: char_syl_freq or char_syl_ngram or word2vec_embedding or fasttext_embedding')
+    parser.add_argument('--mode', choices=['train', 'detect', 'predict'], required=True, help='Mode of operation: build or detect or predict, predict is only for FastText Classification Model')
+    parser.add_argument('--input', type=str, required=True, help='Input file path.')
+    parser.add_argument('--output', type=str, help='Output file path (only for profile creation).', default=None)
+    parser.add_argument('--profiles', type=str, help='Folder path containing saved frequency profiles (only for detection).', default=None)
+    parser.add_argument('--ngram', type=int, help='Maximum n-gram value (default: 3).', default=3)
+    parser.add_argument('--size', type=int, default=100, help='Dimension of the embeddings (default: 100)')
+    parser.add_argument('--window', type=int, default=5, help='Maximum distance between the current and predicted word (default: 5), for embeddings')
+    parser.add_argument('--min_count', type=int, default=2, help='Ignores all words with total frequency lower than this (default: 2), for embeddings')
+    parser.add_argument('--epoch', type=int, default=25, help='Number of epochs for training (default: 25), for FastText Classification and Neural Network approaches')
+    parser.add_argument('--lr', type=float, default=1.0, help='Learning rate for training (default: 1.0), for FastText Classification and Neural Network approaches')
+    parser.add_argument('--wordNgrams', type=int, default=2, help='Max length of word ngram (default: 2)')
+    parser.add_argument('--num_words', type=int, default=10000, help='Number of words to consider from the dataset (default: 10000)')
+    parser.add_argument('--max_len', type=int, default=100, help='Maximum length of the sequences (default: 100)')
+    parser.add_argument('--batch_size', type=int, default=32, help='Batch size for training (default: 32)')
+    parser.add_argument('--verbose', action='store_true', help='Display warning messages., for FastText Classification')
+
+    args = parser.parse_args()
+
+    input_data = args.input
+    if os.path.isfile(input_data):
+        with open(input_data, 'r', encoding='utf-8') as file:
+            raw_text = file.read()
+    else:
+        raw_text = input_data
+
+    if args.approach == 'char_syl_freq':
+        if args.mode == 'train':
+            if not args.input or not args.output or not args.approach:
+                print("For training, both --input, --approach and --output arguments are required.")
+            else:
+                frequency_profile = create_frequency_profile(raw_text)
+                save_freq_profile(frequency_profile, args.output)
+                print(f"Frequency profile saved to {args.output}")
+
+        elif args.mode == 'detect':
+            if not args.input or not args.profiles:
+                print("For detection, both --input and --profiles arguments are required.")
+            else:
+                profiles = load_freq_profiles(args.profiles)
+                detected_language = detect_language_freq(raw_text, profiles)
+                print(f"Detected language: {detected_language}")
+
+    elif args.approach == 'char_syl_ngram':
+        if args.mode == 'train':
+            # Create the "profiles" folder if it doesn't exist
+            #if not os.path.exists('profiles'):
+            #    os.makedirs('profile')
+
+            # Create both character and syllable profiles
+            if not args.input or not args.output:
+                print("For training, both --input and --output arguments are required.")
+            else:
+                char_profile = train_naive_bayes(raw_text, args.ngram, use_syllables=False)
+                syl_profile = train_naive_bayes(raw_text, args.ngram, use_syllables=True)
+                combined_profile = {**char_profile, **syl_profile}  # Combine both profiles
+
+            if args.output:
+                with open(args.output, 'w', encoding='utf-8') as file:
+                    for ngram, prob in combined_profile.items():
+                        file.write(f"{ngram}\t{prob}\n")
+            else:
+                for ngram, prob in combined_profile.items():
+                    sys.stdout.write(f"{ngram}\t{prob}\n")
+
+        elif args.mode == 'detect':
+
+            if not args.profiles:
+                print("Please provide a profiles folder for detection using -p or --profile_folder!")
+                sys.exit(1)
+
+            # Character-based detection
+            char_probabilities = detect_language_naive_bayes(raw_text, args.profiles, args.ngram, use_syllables=False, verbose=args.verbose)
+            print("Character-based Detection:")
+            for lang, prob in char_probabilities.items():
+                print(f"{lang}: {prob*100:.2f}%")
+
+            # Syllable-based detection
+            syl_probabilities = detect_language_naive_bayes(raw_text, args.profiles, args.ngram, use_syllables=True, verbose=args.verbose)
+            print("\nSyllable-based Detection:")
+            for lang, prob in syl_probabilities.items():
+                print(f"{lang}: {prob*100:.2f}%")
+
+            # Combined detection
+            print("\nCombined Character and Syllable-based Detection:")
+            combined_scores = defaultdict(float)
+            for lang in char_probabilities:
+                combined_scores[lang] = (char_probabilities[lang] + syl_probabilities[lang]) / 2
+            for lang, score in combined_scores.items():
+                print(f"{lang}: {score*100:.2f}%")
+
+    elif args.approach == 'word2vec_embedding':
+
+        method = "word2vec"
+        if args.mode == 'train':
+            if not args.input or not args.output or not args.approach:
+                print("For training, both --input, --approach and --output arguments are required.")
+            else:
+                model = train_embeddings(args.input, method, args.size, args.window, args.min_count)
+                save_embed_model(model, args.output)
+                print(f"Model saved to {args.output}")
+        elif args.mode == 'detect':
+            if not args.input or not args.approach or not args.profiles:
+                print("For detection, both --input, --approach  and --profiles arguments are required.")
+            else:
+                models = {fname.split('.')[0]: load_embed_model(os.path.join(args.profile, fname))
+                          for fname in os.listdir(args.profile) if fname.endswith('.model')}
+
+                # Check if the input is a file path or a string
+                if os.path.isfile(args.input):
+                    with open(args.input, 'r', encoding='utf-8') as file:
+                        text = file.read()
+                else:
+                    text = args.input
+
+                detected_language = detect_language(text, models)
+                print(f"Detected language: {detected_language}")
+
+    elif args.approach == 'fasttext_embedding':
+
+        method = "fasttext"
+        if args.mode == 'train':
+            if not args.input or not args.output or not args.approach:
+                print("For training, both --input, --approach and --output arguments are required.")
+            else:
+                model = train_embeddings(args.input, method, args.size, args.window, args.min_count)
+                save_embed_model(model, args.output)
+                print(f"Model saved to {args.output}")
+
+        elif args.mode == 'detect':
+            if not args.input or not args.model_folder or not args.approach:
+                print("For detection, both --input, --approach  and --model_folder arguments are required.")
+            else:
+                models = {fname.split('.')[0]: load_embed_model(os.path.join(args.profile, fname))
+                          for fname in os.listdir(args.profile) if fname.endswith('.model')}
+
+                # Check if the input is a file path or a string
+                if os.path.isfile(args.input):
+                    with open(args.input, 'r', encoding='utf-8') as file:
+                        text = file.read()
+                else:
+                    text = args.input
+
+                detected_language = detect_language(text, models)
+                print(f"Detected language: {detected_language}")
+
+    elif args.approach == 'fasttext_class':
+        if args.mode == 'train':
+            if not args.input or not args.output or not args.approach:
+                print("For training, both --input, --approach and --output arguments are required.")
+            else:
+                fasttext_class_train_model(args.input, args.output, args.epoch, args.lr, args.wordNgrams)
+
+        elif args.mode == 'detect':
+            if not args.profiles or not args.input:
+                print("For testing, both --profiles and --input arguments are required.")
+            else:
+                fasttext_class_test_model(args.profiles, args.input)
+
+        elif args.mode == 'predict':
+            if not args.profiles or not args.input:
+                print("For prediction, both --profiles and --input arguments are required.")
+            else:
+                if os.path.isfile(args.input):
+                    predict_language(args.profiles, args.input, is_file=True)
+                else:
+                    prediction = predict_language(args.profiles, args.input)
+                    print(f"Predicted language: {prediction}")
+
+    elif args.approach == 'neural_network':
+        if args.mode == 'train':
+            if not args.input or not args.output or not args.approach:
+                print("For training, both --input, --approach and --output arguments are required.")
+                exit(1)
+
+            texts, labels = load_neural_data(args.input)
+            X, y, tokenizer, label_encoder = neural_preprocess_data(texts, labels, args.num_words, args.max_len)
+            X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2)
+
+            model = build_neural_model(args.max_len, len(label_encoder.classes_), args.num_words)
+            train_neural_model(model, X_train, y_train, X_val, y_val, args.epoch, args.batch_size)
+            save_model_and_artifacts(model, tokenizer, label_encoder, args.output)
+            print(f"Model and artifacts saved to {args.output}")
+
+        elif args.mode == 'detect':
+            if not args.input or not args.profiles:
+                print("For detection, both --input, --approach and --profiles arguments are required.")
+                exit(1)
+
+            model, tokenizer, label_encoder = load_model_and_artifacts(args.profiles)
+
+            if os.path.isfile(args.input):
+                with open(args.input, 'r', encoding='utf-8') as file:
+                    text = file.read().strip()
+            else:
+                text = args.input.strip()
+
+            detected_language = detect_language_neural(text, model, tokenizer, label_encoder, args.max_len)
+            print(f"Detected language: {detected_language}")
+
+    else:
+        print("Invalid approach. Please choose either 'char_syl_freq' or 'char_syl_ngram' or 'word2vec_embedding' or 'fasttext_embedding' or 'fasttext_class' or 'neural_network.")
+
+if __name__ == '__main__':
+    main()
+

detect_with_char_syl_freq.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# Define directories
+BASE_DIR="$HOME/exp/myNLP/lang_detect/"
+PYTHON_SCRIPT="$BASE_DIR/demo_usage.py"
+INPUT_DIR="$BASE_DIR/data/eg_input_raw"
+PROFILE_DIR="$BASE_DIR/profile/char_syl_freq_profile"
+
+# Number of random sentences to test
+NUM_RANDOM_SENTENCES=10
+
+# Loop through each input file in the directory
+for input_file in "$INPUT_DIR"/*.raw; do
+    echo "Processing file: $(basename "$input_file")"
+    
+    # Run detection on the entire file
+    python "$PYTHON_SCRIPT" --input "$input_file" --mode detect --profiles "$PROFILE_DIR" --approach char_syl_freq;
+    
+    # Extract and predict random sentences from the file
+    for i in $(seq 1 $NUM_RANDOM_SENTENCES); do
+        random_sentence=$(shuf -n 1 "$input_file")
+        echo "Predicting random sentence $i: $random_sentence"
+        python "$PYTHON_SCRIPT" --input "$random_sentence" --mode detect --profiles "$PROFILE_DIR" --approach char_syl_freq;
+    done
+
+    echo ""
+done
+
+echo "All processing completed."
+

detect_with_char_syl_ngram.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# Define base directory and script location
+BASE_DIR="/home/ye/exp/myNLP/lang_detect/"
+PYTHON_SCRIPT="$BASE_DIR/demo_usage.py"
+INPUT_DIR="$BASE_DIR/data/eg_input_raw"
+
+# Number of ngrams and random sentences
+NGRAMS=(3 4 5)
+NUM_RANDOM_SENTENCES=10
+
+# Loop through each input file
+for input_file in "$INPUT_DIR"/*.raw; do
+    echo "Processing file: $(basename "$input_file")"
+
+    # Loop through each ngram
+    for ngram in "${NGRAMS[@]}"; do
+        PROFILE_DIR="$BASE_DIR/profile/${ngram}gram_profile"
+
+        # Run the first command
+        echo "Running with ngram=$ngram on full file"
+        python "$PYTHON_SCRIPT" --mode detect --input "$input_file" --profiles "$PROFILE_DIR" --ngram $ngram --approach char_syl_ngram
+
+        # Extract and run the second command on random sentences
+        for i in $(seq 1 $NUM_RANDOM_SENTENCES); do
+            random_sentence=$(shuf -n 1 "$input_file")
+            echo "Running with ngram=$ngram on random sentence $i: $random_sentence"
+            python "$PYTHON_SCRIPT" --mode detect --input "$random_sentence" --profiles "$PROFILE_DIR" --ngram $ngram --approach char_syl_ngram
+        done
+    done
+
+    echo ""
+done
+
+echo "All processing completed."
+

detect_with_embedding.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+# Define base directory, Python script, and input directory
+BASE_DIR="$HOME/exp/sylbreak4all/lang_detection/embedding"
+PYTHON_SCRIPT="$BASE_DIR/embed_lang_detect.py"  # Replace with the name of your Python script
+INPUT_DIR="$BASE_DIR/data/eg_input"
+WORD2VEC_DIR="$BASE_DIR/word2vec"
+FASTTEXT_DIR="$BASE_DIR/fasttext"
+
+# Function to run language detection
+run_detection() {
+    model_type=$1
+    model_dir=$2
+    echo "Running language detection using $model_type models..."
+    for file in "$INPUT_DIR"/*; do
+        filename=$(basename -- "$file")
+        detected_language=$(python3 "$PYTHON_SCRIPT" --mode detect --input "$file" --model_folder "$model_dir")
+        echo "File: $filename - Detected Language with $model_type: $detected_language"
+
+        # Run detection on random sentences from the file, 10 times
+        for i in {1..10}; do
+            random_sentence=$(shuf -n 1 "$file")
+            echo "Attempt $i - Random sentence from $filename: $random_sentence"
+            detected_language_sentence=$(python3 "$PYTHON_SCRIPT" --mode detect --input "$random_sentence" --model_folder "$model_dir")
+            echo "Detected Language with $model_type: $detected_language_sentence"
+        done
+        echo ""
+    done
+}
+
+# Run detection using Word2Vec models
+run_detection "Word2Vec" "$WORD2VEC_DIR"
+
+# Run detection using FastText models
+run_detection "FastText" "$FASTTEXT_DIR"
+
+echo "Language detection completed for all files."
+

detect_with_fasttext.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# Define directories
+BASE_DIR="$HOME/exp/myNLP/lang_detect"
+PYTHON_SCRIPT="$BASE_DIR/demo_usage.py"
+
+# Define the test file
+TEST_FILE="$BASE_DIR/data/all_test.fasttext.shuf"
+
+# Number of random sentences to test
+NUM_RANDOM_SENTENCES=10
+
+# Loop through each model file
+for model in "$BASE_DIR"/profile/fasttext_class/*gram.model.bin; do
+    echo "Processing with model: $(basename "$model")"
+
+    # Test the model with the specific test file
+    echo "Testing with file: $(basename "$TEST_FILE") and model: $(basename "$model")"
+    time python "$PYTHON_SCRIPT" --mode detect --approach fasttext_class \
+--profile "$model" --input "$TEST_FILE"
+
+    # Extract and predict random sentences from the test file
+    for i in $(seq 1 $NUM_RANDOM_SENTENCES); do
+        random_sentence=$(shuf -n 1 "$TEST_FILE")
+        echo "Predicting random sentence $i: $random_sentence"
+        python "$PYTHON_SCRIPT" --mode predict --approach fasttext_class \
+--profile "$model" --input "$random_sentence"
+    done
+
+    echo ""
+done
+
+echo "All processing completed."
+

detect_with_neural.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Define base directory and Python script
+BASE_DIR="$HOME/exp/myNLP/lang_detect"
+PYTHON_SCRIPT="$BASE_DIR/demo_usage.py"
+
+# Directory containing the language files
+INPUT_DIR="$BASE_DIR/data/eg_input/"
+
+# Directory of the trained model
+MODEL_DIR="$BASE_DIR/profile/neural/"
+
+# Number of random sentences to test
+NUM_RANDOM_SENTENCES=10
+
+# Loop through each .txt file in the input directory
+for file in "$INPUT_DIR"*.txt; do
+    echo "Processing file $file..."
+    python "$PYTHON_SCRIPT" --mode detect --approach neural_network --input "$file" --profiles "$MODEL_DIR"
+
+    # Extract and predict random sentences from the file
+    for i in $(seq 1 $NUM_RANDOM_SENTENCES); do
+        random_sentence=$(shuf -n 1 "$file")
+        echo "Predicting random sentence $i from $file: $random_sentence"
+        python "$PYTHON_SCRIPT" --mode detect --approach neural_network --input "$random_sentence" --profiles "$MODEL_DIR"
+    done
+
+    echo ""
+done
+
+echo "All processing completed."
+

exp.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# Demo profile building and detecting with all approaches
+# Written by Ye Kyaw Thu, LU Lab., Myanmar
+# Last updated: 31 Jan 2024
+
+mkdir log;
+
+time ./build_profile_with_char_syl_freq.sh | tee ./log/char_syl_freq.train.log
+time ./detect_with_char_syl_freq.sh | tee ./log/char_syl_freq.detect.log
+
+time ./build_profile_with_char_syl_ngram.sh | tee ./log/| tee ./log/char_syl_ngram.train.log
+time ./detect_with_char_syl_ngram.sh | tee ./log/char_syl_ngram.detect.log
+
+time ./build_profile_with_embeddings.sh | tee ./log/embeddings.train.log
+time ./detect_with_embedding.sh | tee ./log/embeddings.detect.log
+
+time ./train_with_fasttext_classifier.sh | tee ./log/fasttext_class.train.log
+time ./detect_with_fasttext.sh | tee ./log/fasttext_class.detect.log
+
+time ./train_with_nerual.sh | tee ./log/neural.train.log
+time ./detect_with_neural.sh | tee ./log/neural.detect.log

train_with_fasttext_classifier.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# Define the base directory, input data, and the Python script
+BASE_DIR="$HOME/exp/myNLP/lang_detect"
+PYTHON_SCRIPT="$BASE_DIR/demo_usage.py"
+INPUT_DATA="$BASE_DIR/data/all_languages.fasttext"
+FASTTEXT_DIR="$BASE_DIR/profile/fasttext_class"
+
+# Create the directory for FastText models if it doesn't exist
+mkdir -p "$FASTTEXT_DIR"
+
+# Loop over the desired n-grams (3 to 7)
+for ngram in {3..7}; do
+    # Define the output model filename
+    model_output="${FASTTEXT_DIR}/${ngram}gram.model.bin"
+
+    # Training the model
+    time python3 "$PYTHON_SCRIPT" --mode train --input "$INPUT_DATA" \
+    --output "$model_output" --epoch 25 --lr 1.0 --wordNgrams $ngram \
+    --approach fasttext_class
+
+    echo "FastText model with ${ngram}-gram saved to $model_output"
+done
+
+echo "Training completed for all n-grams."
+

train_with_nerual.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+python ./demo_usage.py --mode train --approach neural_network \
+--input ./data/all_languages_neural.txt --output ./profile/neural/