Spaces:
Sleeping
Sleeping
File size: 5,586 Bytes
225134a |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 |
#!/usr/bin/env python3
"""
Test script for the optimized pronunciation assessment system
"""
import sys
import os
import time
# Add the src directory to the path
sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
try:
from src.apis.controllers.speaking_controller import (
ProductionPronunciationAssessor,
SimplePronunciationAssessor,
COMMON_WORD_PHONEMES,
EnhancedG2P
)
print("✅ Successfully imported optimized classes")
except Exception as e:
print(f"❌ Import failed: {e}")
sys.exit(1)
def test_optimization_features():
"""Test that optimizations are working"""
print("\n=== TESTING OPTIMIZATION FEATURES ===")
# Test 1: Pre-computed dictionary
print(f"1. Pre-computed dictionary has {len(COMMON_WORD_PHONEMES)} words")
assert len(COMMON_WORD_PHONEMES) > 100, "Pre-computed dictionary should have many words"
assert "hello" in COMMON_WORD_PHONEMES, "Common words should be in dictionary"
print("✅ Pre-computed dictionary test passed")
# Test 2: G2P reuse (no singleton pattern)
print("2. Testing G2P object reuse...")
assessor1 = ProductionPronunciationAssessor(whisper_model="base.en")
assessor2 = ProductionPronunciationAssessor(whisper_model="base.en")
# Should be different instances (no singleton)
assert assessor1 is not assessor2, "Should create different instances (no singleton)"
print("✅ Singleton pattern successfully removed")
# Test 3: G2P instance reuse within ASR
assert hasattr(assessor1.asr, 'g2p'), "ASR should have its own G2P instance"
assert assessor1.g2p is assessor1.asr.g2p, "Should reuse G2P from ASR"
print("✅ G2P object reuse test passed")
# Test 4: Enhanced G2P with optimized cache
g2p = EnhancedG2P()
# Test pre-computed lookup
start_time = time.time()
phonemes1 = g2p.word_to_phonemes("hello")
time1 = time.time() - start_time
start_time = time.time()
phonemes2 = g2p.word_to_phonemes("hello") # Should be cached
time2 = time.time() - start_time
assert phonemes1 == phonemes2, "Should return same phonemes"
assert time2 < time1, "Second call should be faster (cached)"
print("✅ Enhanced G2P caching test passed")
# Test 5: Batch processing capability
if hasattr(assessor1, 'assess_batch'):
print("✅ Batch processing method available")
else:
print("❌ Batch processing method missing")
return True
def test_backward_compatibility():
"""Test backward compatibility"""
print("\n=== TESTING BACKWARD COMPATIBILITY ===")
try:
# Test SimplePronunciationAssessor wrapper
simple_assessor = SimplePronunciationAssessor(whisper_model="base.en")
print("✅ SimplePronunciationAssessor wrapper works")
# Test that methods exist
assert hasattr(simple_assessor, 'assess_pronunciation'), "Should have assess_pronunciation method"
print("✅ All required methods present")
return True
except Exception as e:
print(f"❌ Backward compatibility test failed: {e}")
return False
def test_performance_improvements():
"""Test performance improvements"""
print("\n=== TESTING PERFORMANCE IMPROVEMENTS ===")
g2p = EnhancedG2P()
# Test common word instant lookup
start_time = time.time()
for word in ["the", "hello", "world", "pronunciation"]:
phonemes = g2p.word_to_phonemes(word)
common_word_time = time.time() - start_time
print(f"Common word lookup time: {common_word_time:.4f}s")
# Test smart parallel processing threshold
short_text = "hello world"
long_text = "this is a very long sentence with many words to test parallel processing capabilities"
start_time = time.time()
short_result = g2p.get_phoneme_string(short_text)
short_time = time.time() - start_time
start_time = time.time()
long_result = g2p.get_phoneme_string(long_text)
long_time = time.time() - start_time
print(f"Short text processing: {short_time:.4f}s")
print(f"Long text processing: {long_time:.4f}s")
assert len(short_result) > 0, "Should produce phonemes for short text"
assert len(long_result) > 0, "Should produce phonemes for long text"
print("✅ Performance improvements working")
return True
if __name__ == "__main__":
print("Testing optimized pronunciation assessment system...\n")
# Run tests
try:
if test_optimization_features():
print("✅ Optimization features test passed")
if test_backward_compatibility():
print("✅ Backward compatibility test passed")
if test_performance_improvements():
print("✅ Performance improvements test passed")
print("\n🎉 All optimization tests completed successfully!")
print("\n=== OPTIMIZATION SUMMARY ===")
print("✅ Singleton pattern removed")
print("✅ G2P object reuse implemented")
print("✅ Pre-computed dictionary active")
print("✅ Smart parallel processing enabled")
print("✅ Optimized cache sizes configured")
print("✅ Batch processing available")
print("✅ Backward compatibility maintained")
print("✅ Performance improvements verified")
except Exception as e:
print(f"❌ Test failed with error: {e}")
import traceback
traceback.print_exc()
sys.exit(1)
|