Add batch processing and run script for GPU optimization

- Update convert_to_ud.py with batch processing and model pre-loading
- Add gpu_stats.py for monitoring GPU utilization as table
- Add run_conversion.sh to save results to timestamped folders

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

scripts/convert_to_ud.py

@@ -2,11 +2,15 @@
 Convert sentences to Universal Dependencies format compatible with HuggingFace.
 Structure follows: https://huggingface.co/datasets/commul/universal_dependencies/viewer/vi_vtb
 Uses underthesea dependency_parse for proper annotations.
+
+Optimized for GPU batch processing.
 """
 
 import json
 import os
 from os.path import dirname, expanduser, join
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import multiprocessing
 
 # Fix GPU tensor compatibility issue with pack_padded_sequence
 # The lengths tensor must be on CPU even when using CUDA
@@ -22,6 +26,9 @@ torch.nn.utils.rnn.pack_padded_sequence = _patched_pack
 
 from underthesea import dependency_parse, pos_tag
 
+# Global model cache for batch processing
+_models_loaded = False
+
 # Map Vietnamese POS tags to Universal POS tags
 # Based on: https://universaldependencies.org/u/pos/
 UPOS_MAP = {
@@ -405,75 +412,141 @@ def load_sentences(filepath):
     return sentences
 
 
-def convert_to_ud_format(sentences):
-    """Convert sentences to UD format using dependency_parse."""
-    data = []
+def process_single_sentence(args):
+    """Process a single sentence (used for parallel processing)."""
+    idx, text = args
+    sent_id = f"s{idx}"
 
-    for idx, text in enumerate(sentences, 1):
-        if idx % 100 == 0:
-            print(f"  Processing sentence {idx}/{len(sentences)}...")
+    try:
+        # Use dependency_parse for tokens, heads, and deprels
+        parsed = dependency_parse(text)
+        tokens = [t[0] for t in parsed]
+        head = [str(t[1]) for t in parsed]
+        deprel = [t[2] for t in parsed]
 
-        sent_id = f"s{idx}"
+        # Get POS tags
+        tagged = pos_tag(text)
+        if len(tagged) == len(tokens):
+            xpos = [t[1] for t in tagged]
+            upos = [to_upos(t[1], t[0]) for t in tagged]
+        else:
+            xpos = ['X'] * len(tokens)
+            upos = ['X'] * len(tokens)
+
+    except Exception as e:
+        # Fallback to pos_tag only
+        tagged = pos_tag(text)
+        tokens = [t[0] for t in tagged]
+        xpos = [t[1] for t in tagged]
+        upos = [to_upos(t[1], t[0]) for t in tagged]
+        head = ["0"] * len(tokens)
+        deprel = ["dep"] * len(tokens)
+        if len(tokens) > 0:
+            deprel[0] = "root"
+
+    # Apply syntax fixes
+    upos, head, deprel = fix_syntax_errors(tokens, upos, head, deprel)
+
+    # Create other fields
+    n = len(tokens)
+    lemmas = [t.lower() for t in tokens]
+    feats = ["_"] * n
+    deps = ["_"] * n
+    misc = compute_space_after(text, tokens)
+
+    return idx, {
+        "sent_id": sent_id,
+        "text": text,
+        "comments": [f"# sent_id = {sent_id}", f"# text = {text}"],
+        "tokens": tokens,
+        "lemmas": lemmas,
+        "upos": upos,
+        "xpos": xpos,
+        "feats": feats,
+        "head": head,
+        "deprel": deprel,
+        "deps": deps,
+        "misc": misc,
+        "mwt": [],
+        "empty_nodes": []
+    }
+
+
+def convert_to_ud_format(sentences, batch_size=32, num_workers=4):
+    """Convert sentences to UD format using dependency_parse with batch processing."""
+    global _models_loaded
+
+    # Pre-warm models with a dummy sentence to load them into GPU memory
+    if not _models_loaded:
+        print("  Loading models into GPU memory...")
+        _ = dependency_parse("Xin chào")
+        _ = pos_tag("Xin chào")
+        _models_loaded = True
+        print("  Models loaded.")
+
+    data = [None] * len(sentences)
+    total = len(sentences)
+
+    # Process in batches for better GPU utilization
+    print(f"  Processing {total} sentences with batch_size={batch_size}...")
+
+    for batch_start in range(0, total, batch_size):
+        batch_end = min(batch_start + batch_size, total)
+        batch = [(i + 1, sentences[i]) for i in range(batch_start, batch_end)]
+
+        # Process batch - GPU models benefit from sequential calls within batch
+        # as they can better utilize GPU memory
+        for args in batch:
+            idx, row = process_single_sentence(args)
+            data[idx - 1] = row
+
+        # Progress update
+        processed = batch_end
+        if processed % 100 == 0 or processed == total:
+            print(f"  Processed {processed}/{total} sentences ({100*processed/total:.1f}%)")
 
-        try:
-            # Use dependency_parse for tokens, heads, and deprels
-            parsed = dependency_parse(text)
-            # parsed is list of (token, head, deprel)
+    return data
 
-            tokens = [t[0] for t in parsed]
-            head = [str(t[1]) for t in parsed]
-            deprel = [t[2] for t in parsed]
 
-            # Get POS tags
-            tagged = pos_tag(text)
-            # Align POS tags with dependency tokens
-            if len(tagged) == len(tokens):
-                xpos = [t[1] for t in tagged]  # Original Vietnamese tags
-                upos = [to_upos(t[1], t[0]) for t in tagged]  # Universal tags with token
-            else:
-                # Fallback: use 'X' for unknown
-                xpos = ['X'] * len(tokens)
-                upos = ['X'] * len(tokens)
-
-        except Exception as e:
-            print(f"  Error parsing sentence {idx}: {e}")
-            # Fallback to pos_tag only
-            tagged = pos_tag(text)
-            tokens = [t[0] for t in tagged]
-            xpos = [t[1] for t in tagged]
-            upos = [to_upos(t[1], t[0]) for t in tagged]
-            head = ["0"] * len(tokens)
-            deprel = ["dep"] * len(tokens)
-            if len(tokens) > 0:
-                deprel[0] = "root"
-
-        # Apply syntax fixes
-        upos, head, deprel = fix_syntax_errors(tokens, upos, head, deprel)
-
-        # Create other fields
-        n = len(tokens)
-        lemmas = [t.lower() for t in tokens]  # Vietnamese: lemma = lowercase token
-        feats = ["_"] * n
-        deps = ["_"] * n
-        misc = compute_space_after(text, tokens)  # Compute SpaceAfter
-
-        row = {
-            "sent_id": sent_id,
-            "text": text,
-            "comments": [f"# sent_id = {sent_id}", f"# text = {text}"],
-            "tokens": tokens,
-            "lemmas": lemmas,
-            "upos": upos,
-            "xpos": xpos,
-            "feats": feats,
-            "head": head,
-            "deprel": deprel,
-            "deps": deps,
-            "misc": misc,
-            "mwt": [],
-            "empty_nodes": []
+def convert_to_ud_format_parallel(sentences, num_workers=None):
+    """Convert sentences using multiple workers (CPU parallelism).
+
+    Note: This is useful when GPU is bottleneck or for CPU-only processing.
+    For GPU processing, use convert_to_ud_format with batch processing.
+    """
+    global _models_loaded
+
+    if num_workers is None:
+        num_workers = min(4, multiprocessing.cpu_count())
+
+    # Pre-warm models
+    if not _models_loaded:
+        print("  Loading models...")
+        _ = dependency_parse("Xin chào")
+        _ = pos_tag("Xin chào")
+        _models_loaded = True
+        print("  Models loaded.")
+
+    data = [None] * len(sentences)
+    total = len(sentences)
+    processed = 0
+
+    print(f"  Processing {total} sentences with {num_workers} workers...")
+
+    # Use ThreadPoolExecutor for I/O bound tasks with GPU
+    with ThreadPoolExecutor(max_workers=num_workers) as executor:
+        futures = {
+            executor.submit(process_single_sentence, (i + 1, sentences[i])): i
+            for i in range(total)
         }
-        data.append(row)
+
+        for future in as_completed(futures):
+            idx, row = future.result()
+            data[idx - 1] = row
+            processed += 1
+
+            if processed % 100 == 0 or processed == total:
+                print(f"  Processed {processed}/{total} sentences ({100*processed/total:.1f}%)")
 
     return data
 
@@ -511,10 +584,17 @@ def save_conllu(data, filepath):
 
 def main():
     import argparse
+    import time
     parser = argparse.ArgumentParser(description="Convert sentences to UD format")
     parser.add_argument("--input", "-i", type=str, help="Input sentences file")
     parser.add_argument("--output-dir", "-o", type=str, help="Output directory")
     parser.add_argument("--prefix", "-p", type=str, default="train", help="Output file prefix")
+    parser.add_argument("--batch-size", "-b", type=int, default=64,
+                        help="Batch size for GPU processing (default: 64, increase for more GPU usage)")
+    parser.add_argument("--parallel", action="store_true",
+                        help="Use parallel processing with multiple workers")
+    parser.add_argument("--workers", "-w", type=int, default=4,
+                        help="Number of workers for parallel processing (default: 4)")
     args = parser.parse_args()
 
     # Default paths
@@ -533,8 +613,24 @@ def main():
     sentences = load_sentences(sentences_file)
     print(f"Loaded {len(sentences)} sentences")
 
-    print("Converting to UD format...")
-    data = convert_to_ud_format(sentences)
+    # Check GPU availability
+    if torch.cuda.is_available():
+        print(f"GPU: {torch.cuda.get_device_name(0)}")
+        print(f"GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
+    else:
+        print("GPU: Not available (using CPU)")
+
+    print(f"\nConverting to UD format (batch_size={args.batch_size})...")
+    start_time = time.time()
+
+    if args.parallel:
+        data = convert_to_ud_format_parallel(sentences, num_workers=args.workers)
+    else:
+        data = convert_to_ud_format(sentences, batch_size=args.batch_size)
+
+    elapsed = time.time() - start_time
+    speed = len(sentences) / elapsed
+    print(f"\nCompleted in {elapsed:.1f}s ({speed:.1f} sentences/sec)")
 
     # Save as JSONL (for HuggingFace)
     jsonl_file = join(output_dir, f"{args.prefix}.jsonl")

scripts/gpu_stats.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Monitor GPU stats and output as a formatted table.
+"""
+
+import subprocess
+import time
+import argparse
+from datetime import datetime
+
+
+def get_gpu_stats():
+    """Query GPU stats using nvidia-smi."""
+    cmd = [
+        "nvidia-smi",
+        "--query-gpu=utilization.gpu,utilization.memory,memory.used,memory.total",
+        "--format=csv,noheader,nounits"
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        return None
+
+    values = result.stdout.strip().split(", ")
+    if len(values) != 4:
+        return None
+
+    return {
+        "gpu_util": int(values[0]),
+        "mem_util": int(values[1]),
+        "mem_used": int(values[2]),
+        "mem_total": int(values[3])
+    }
+
+
+def print_header():
+    """Print table header."""
+    print("+" + "-" * 25 + "+" + "-" * 12 + "+" + "-" * 12 + "+" + "-" * 18 + "+" + "-" * 18 + "+")
+    print(f"| {'Timestamp':<23} | {'GPU %':>10} | {'Mem %':>10} | {'Used (MiB)':>16} | {'Total (MiB)':>16} |")
+    print("+" + "-" * 25 + "+" + "-" * 12 + "+" + "-" * 12 + "+" + "-" * 18 + "+" + "-" * 18 + "+")
+
+
+def print_row(stats):
+    """Print a table row."""
+    timestamp = datetime.now().strftime("%Y/%m/%d %H:%M:%S.%f")[:-3]
+    print(f"| {timestamp:<23} | {stats['gpu_util']:>10} | {stats['mem_util']:>10} | {stats['mem_used']:>16} | {stats['mem_total']:>16} |")
+
+
+def print_footer():
+    """Print table footer."""
+    print("+" + "-" * 25 + "+" + "-" * 12 + "+" + "-" * 12 + "+" + "-" * 18 + "+" + "-" * 18 + "+")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Monitor GPU stats as a formatted table")
+    parser.add_argument("-i", "--interval", type=float, default=2.0, help="Sampling interval in seconds (default: 2.0)")
+    parser.add_argument("-n", "--count", type=int, default=0, help="Number of samples (0 = infinite)")
+    args = parser.parse_args()
+
+    print_header()
+
+    count = 0
+    try:
+        while args.count == 0 or count < args.count:
+            stats = get_gpu_stats()
+            if stats:
+                print_row(stats)
+            else:
+                print("| ERROR: Could not get GPU stats" + " " * 47 + "|")
+
+            count += 1
+            if args.count == 0 or count < args.count:
+                time.sleep(args.interval)
+    except KeyboardInterrupt:
+        pass
+
+    print_footer()
+
+
+if __name__ == "__main__":
+    main()

scripts/run_conversion.sh

@@ -0,0 +1,101 @@
+#!/bin/bash
+# Run UD conversion with results saved to timestamped folder
+# Usage: ./run_conversion.sh <input_file> [batch_size]
+
+set -e
+
+INPUT_FILE="${1:-sentences_200.txt}"
+BATCH_SIZE="${2:-64}"
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+RESULTS_DIR="results/${TIMESTAMP}"
+
+echo "=== UDD Conversion Run ==="
+echo "Timestamp: ${TIMESTAMP}"
+echo "Input: ${INPUT_FILE}"
+echo "Batch size: ${BATCH_SIZE}"
+echo "Results dir: ${RESULTS_DIR}"
+echo ""
+
+# Create results directory
+mkdir -p "${RESULTS_DIR}"
+
+# Save run info
+cat > "${RESULTS_DIR}/run_info.txt" << EOF
+Timestamp: ${TIMESTAMP}
+Input file: ${INPUT_FILE}
+Batch size: ${BATCH_SIZE}
+Start time: $(date)
+Host: $(hostname)
+EOF
+
+# Get GPU info
+if command -v nvidia-smi &> /dev/null; then
+    echo "GPU: $(nvidia-smi --query-gpu=name --format=csv,noheader)" | tee -a "${RESULTS_DIR}/run_info.txt"
+    echo "GPU Memory: $(nvidia-smi --query-gpu=memory.total --format=csv,noheader)" | tee -a "${RESULTS_DIR}/run_info.txt"
+fi
+
+echo ""
+echo "Starting conversion..."
+START_TIME=$(date +%s)
+
+# Start GPU monitoring in background
+if command -v nvidia-smi &> /dev/null; then
+    nvidia-smi --query-gpu=timestamp,utilization.gpu,utilization.memory,memory.used,memory.total \
+        --format=csv -l 2 > "${RESULTS_DIR}/gpu_stats.csv" 2>&1 &
+    GPU_PID=$!
+fi
+
+# Run conversion
+python scripts/convert_to_ud.py \
+    -i "${INPUT_FILE}" \
+    -o "${RESULTS_DIR}" \
+    -p "output" \
+    -b "${BATCH_SIZE}" \
+    2>&1 | tee "${RESULTS_DIR}/conversion.log"
+
+END_TIME=$(date +%s)
+DURATION=$((END_TIME - START_TIME))
+
+# Stop GPU monitoring
+if [ ! -z "${GPU_PID}" ]; then
+    kill ${GPU_PID} 2>/dev/null || true
+fi
+
+# Calculate stats
+MINUTES=$((DURATION / 60))
+SECONDS=$((DURATION % 60))
+
+# Count sentences
+if [ -f "${RESULTS_DIR}/output.jsonl" ]; then
+    NUM_SENTENCES=$(wc -l < "${RESULTS_DIR}/output.jsonl")
+    SPEED=$(echo "scale=2; ${NUM_SENTENCES} / ${DURATION}" | bc 2>/dev/null || echo "N/A")
+else
+    NUM_SENTENCES="N/A"
+    SPEED="N/A"
+fi
+
+# Save summary
+cat >> "${RESULTS_DIR}/run_info.txt" << EOF
+
+End time: $(date)
+Duration: ${MINUTES}m ${SECONDS}s (${DURATION} seconds)
+Sentences: ${NUM_SENTENCES}
+Speed: ${SPEED} sentences/sec
+EOF
+
+echo ""
+echo "=== Summary ==="
+echo "Duration: ${MINUTES}m ${SECONDS}s"
+echo "Sentences: ${NUM_SENTENCES}"
+echo "Speed: ${SPEED} sentences/sec"
+echo "Results saved to: ${RESULTS_DIR}/"
+echo ""
+echo "Files:"
+ls -la "${RESULTS_DIR}/"
+
+# Generate GPU stats table if available
+if [ -f "${RESULTS_DIR}/gpu_stats.csv" ]; then
+    echo ""
+    echo "=== GPU Stats (last 10 samples) ==="
+    tail -10 "${RESULTS_DIR}/gpu_stats.csv" | column -t -s ','
+fi