Welcome aboard, brave code warriors! Today, we're embarking on an epic quest to build, test, and evolve a call intelligence system that turns boring audio files into goldmines of insights. Grab your favourite caffeinated beverage, fire up Google Colab, and let's dive into this adventure!
📚 Table of Contents
- The Quest Begins: Basic Setup
- Building Our Magic Powers
- Testing Our Creation
- Leveling Up: Advanced Features
- Battle-Testing in Production
🏰 The Quest Begins: Basic Setup
First, let's gather our magical ingredients:
!pip install openai # Your trusty spell book
🔐 Securing Your Magic Keys
def setup_api_key():
"""Your secret API key vault 🔐"""
api_key = input("Enter your OpenAI API key (we promise to keep it safe!): ")
os.environ['OPENAI_API_KEY'] = api_key
return "API key secured! 🎉"
settings = setup_api_key()
🧙♂️ Building Our Magic Powers
🎙️ The Speech Whisperer
class AudioWizard:
"""🎙️ Turning speech into text since 2024"""
def __init__(self, api_key):
self.client = OpenAI(api_key=api_key)
print("AudioWizard initialized and ready for action! 🚀")
@retry(tries=3, delay=2) # Magic shield against API hiccups
async def transcribe_audio(self, audio_file_path):
try:
print("🎧 Listening to your audio...")
with open(audio_file_path, "rb") as audio_file:
transcription = await self.client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="verbose_json"
)
print("✨ Translation complete!")
return {
"success": True,
"text": transcription.text,
"confidence": transcription.confidence
}
except Exception as e:
print(f"🚨 Oh no! A wild error appeared: {str(e)}")
return {"success": False, "error": str(e)}
🎭 The Script Enchanter
class ScriptEnchanter:
"""🎬 Making your transcripts ready for Broadway"""
def __init__(self, api_key):
self.client = OpenAI(api_key=api_key)
async def format_script(self, text):
try:
response = await self.client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": """
🎭 You are a master screenplay formatter who:
- Names speakers like a casting director
- Adds emotions and actions in (parentheses)
- Makes conversations flow like poetry
"""},
{"role": "user", "content": f"Transform this into a masterpiece:\n\n{text}"}
],
temperature=0.3
)
return response.choices[0].message.content
except Exception as e:
return f"🎭 Stage fright! Error: {str(e)}"
🧪 Testing Our Creation
🎯 The Test Master
@dataclass
class TestResults:
"""📊 Keeping score of our system's performance"""
accuracy: float
wer: float # Word Error Rate
processing_time: float
confidence_score: float
class TestMaster:
"""🧪 Making sure our magic actually works"""
def __init__(self):
self.test_cases = [
{
"name": "Clear Speech Test",
"file": "test_files/clear_speech.wav",
"expected": "test_files/clear_speech.txt",
"difficulty": "easy"
},
{
"name": "Noisy Battle Test",
"file": "test_files/noisy.wav",
"expected": "test_files/noisy.txt",
"difficulty": "hard"
}
]
self.results = {}
async def run_tests(self):
"""🎯 Running our test gauntlet"""
for test in self.test_cases:
print(f"🏃♂️ Running {test['name']}...")
# Time the spell casting
start_time = time.time()
# Cast our transcription spell
result = await AudioWizard().transcribe_audio(test['file'])
# Calculate our accuracy scores
metrics = self.calculate_metrics(
result['text'],
self.load_expected_text(test['expected']),
time.time() - start_time
)
self.results[test['name']] = metrics
print(f"✅ Test completed with {metrics.accuracy:.1f}% accuracy!")
def calculate_metrics(self, result, expected, time_taken):
"""📐 Measuring our magical accuracy"""
return TestResults(
accuracy=self.calculate_accuracy(result, expected),
wer=self.calculate_wer(result, expected),
processing_time=time_taken,
confidence_score=self.calculate_confidence(result)
)
📊 The Results Visualizer
class ResultsVisualizer:
"""📈 Making our test results look magical"""
def visualize_results(self, results: Dict[str, TestResults]):
"""Create a fancy visualization of our test results"""
plt.figure(figsize=(12, 6))
# Plot accuracy scores
tests = list(results.keys())
accuracies = [r.accuracy for r in results.values()]
plt.bar(tests, accuracies, color='skyblue')
plt.title("🎯 Accuracy Scores", fontsize=15)
plt.ylabel("Accuracy (%)")
# Add some sparkle ✨
for i, v in enumerate(accuracies):
plt.text(i, v + 1, f"{v:.1f}%",
ha='center', fontsize=12)
plt.show()
🆙 Leveling Up: Advanced Features
🌟 The Feature Expander
class FeatureExpander:
"""🌟 Adding new magical powers"""
async def add_speaker_diarization(self, audio):
"""👥 Identifying different speakers"""
try:
# Your speaker diarization code here
print("🎭 Identifying speakers...")
except Exception as e:
print(f"🚨 Speaker identification failed: {str(e)}")
async def add_sentiment_analysis(self, text):
"""😊 Understanding emotional tones"""
try:
response = await self.client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content":
"Analyze the emotional tone of this conversation"},
{"role": "user", "content": text}
]
)
return response.choices[0].message.content
except Exception as e:
return f"😕 Emotion detection failed: {str(e)}"
🧪 Testing New Features
class FeatureTester:
"""🧪 Testing our new magical powers"""
async def test_new_feature(self, feature_name: str, test_data: Dict):
print(f"🧪 Testing {feature_name}...")
start_time = time.time()
try:
# Run the feature
result = await self.run_feature(feature_name, test_data)
# Validate the results
validation = self.validate_feature(feature_name, result)
# Calculate metrics
metrics = {
"success": validation["success"],
"processing_time": time.time() - start_time,
"accuracy": validation["accuracy"]
}
return {
"status": "✅ Test passed!" if validation["success"]
else "❌ Test failed!",
"metrics": metrics
}
except Exception as e:
return {
"status": "💥 Test crashed!",
"error": str(e)
}
⚔️ Battle-Testing in Production
🏆 Performance Testing
class PerformanceTester:
"""⚡ Making sure our system is speed-champion"""
async def run_performance_test(self, test_duration: int = 3600):
"""🏃♂️ Running performance marathon"""
print("🏁 Starting performance test...")
metrics = {
"processed_files": 0,
"average_processing_time": 0,
"error_rate": 0,
"memory_usage": []
}
start_time = time.time()
while time.time() - start_time < test_duration:
# Process test file
result = await self.process_test_file()
# Update metrics
metrics["processed_files"] += 1
metrics["average_processing_time"] = (
(metrics["average_processing_time"] *
(metrics["processed_files"] - 1) +
result["processing_time"]) /
metrics["processed_files"]
)
# Monitor memory
metrics["memory_usage"].append(
psutil.Process().memory_info().rss / 1024 / 1024
)
return metrics
📈 Results Dashboard
class ResultsDashboard:
"""📊 Creating our magical mission control center"""
def create_dashboard(self, metrics: Dict):
"""📊 Building a fancy dashboard"""
fig = plt.figure(figsize=(15, 10))
# Processing time graph
plt.subplot(2, 2, 1)
plt.plot(metrics["processing_times"])
plt.title("⚡ Processing Speed")
# Accuracy graph
plt.subplot(2, 2, 2)
plt.bar(["WER", "Accuracy"],
[metrics["wer"], metrics["accuracy"]])
plt.title("🎯 Accuracy Metrics")
# Memory usage
plt.subplot(2, 2, 3)
plt.plot(metrics["memory_usage"])
plt.title("💾 Memory Usage")
# Error rates
plt.subplot(2, 2, 4)
plt.pie([metrics["success_rate"],
100 - metrics["success_rate"]],
labels=["Success", "Errors"])
plt.title("✅ Success Rate")
plt.tight_layout()
plt.show()
🎮 Putting It All Together
async def run_complete_system():
"""🎮 Running our complete magical system"""
# Initialize our system
print("🧙♂️ Initializing magical systems...")
audio_wizard = AudioWizard(os.getenv('OPENAI_API_KEY'))
test_master = TestMaster()
feature_expander = FeatureExpander()
# Run core functionality tests
print("\n🧪 Testing core magic...")
await test_master.run_tests()
# Test new features
print("\n🌟 Testing new powers...")
feature_results = await FeatureTester().test_new_feature(
"sentiment_analysis",
{"text": "Sample conversation"}
)
# Run performance tests
print("\n⚡ Running speed tests...")
performance_metrics = await PerformanceTester().run_performance_test(
test_duration=300 # 5 minutes test
)
# Create dashboard
print("\n📊 Creating magical dashboard...")
ResultsDashboard().create_dashboard({
**test_master.results,
**performance_metrics
})
print("\n✨ All tests completed! ✨")
# Run everything!
await run_complete_system()
🎓 Pro Tips for the Advanced Wizard
- 🔧 Optimization Spells
# Pre-process audio for better results
audio = (AudioProcessor(file)
.reduce_noise()
.normalize_volume()
.export())
- 🛡️ Error Handling Shield
# Protect against API timeouts
@retry(tries=3, delay=2, backoff=2)
async def protected_api_call():
# Your API calls here
pass
- ⚡ Speed Enchantments
# Batch processing for multiple files
async def process_batch(files):
return await asyncio.gather(
*[process_file(f) for f in files]
)
🎯 Future Quests
Ready to take your system to the next level? Here are some epic quests to pursue:
-
🌈 Multilingual Magic
- Add support for multiple languages
- Implement cross-language translation
- Add cultural context awareness
-
🎭 Advanced Character Recognition
- Improve speaker diarization
- Add emotion detection
- Implement personality insights
-
⚡ Performance Boosters
- Implement caching
- Add distributed processing
- Optimize memory usage
🏆 Victory Lap
Congratulations, brave developer! You've built a powerful call intelligence system, complete with:
- 🎯 Robust testing
- 📊 Performance monitoring
- 🌟 Advanced features
- 🛡️ Error handling
Remember: The best code is like magic - it works reliably, but there's always room for more enchantments!
Now go forth and build amazing things! 🚀✨
P.S. If you find any bugs, they're not bugs - they're just unexpected features taking a vacation! 😉
Top comments (1)
saved, thanks