Published on 27/05/2025
In the increasingly digitized landscape of modern work, the need to convert audio content to text has reached unprecedented levels. Whether it's corporate meetings, journalistic interviews, podcasts, or university lectures, accurate and fast transcription has become a fundamental requirement for professionals in every sector.
In this article, I'll present a comprehensive audio transcription system that I developed using the most advanced Artificial Intelligence technologies, combining cutting-edge speech-to-text models with audio enhancement and speaker diarization techniques. The result is a completely offline, professional, and scalable solution that can transform hours of audio into accurate transcriptions in just minutes.
The system has been designed with a modular architecture that clearly separates responsibilities:
The system's core is based on three technological pillars:
audio-transcription-tool/
├── main.py # Main entry point
├── requirements.txt # Python dependencies
├── README.md # Documentation
├── .gitignore # Git configuration
├──
├── src/ # Core modules
│ ├── __init__.py
│ ├── logger.py # Advanced logging system
│ ├── audio_processor.py # Base audio processing
│ ├── ai_enhancer.py # AI Enhancement (future)
│ ├── model_manager.py # AI model management
│ ├── transcriber.py # Whisper transcription
│ ├── diarizer.py # Speaker diarization
│ └── output_formatter.py # Output formatting
├──
├── models/ # Local AI models
├── examples/ # Usage examples
└── docs/ # Extended documentation
src/audio_processor.py)Handles audio format conversion and basic processing:
src/model_manager.py)Factory pattern for AI model management:
src/transcriber.py)Unified interface for Whisper transcription:
src/diarizer.py)Speaker diarization with PyAnnote:
src/output_formatter.py)Multi-format output generation:
Whisper represents the state-of-the-art in automatic transcription. The system supports all available models:
| Model | Parameters | VRAM | Speed | Quality | Recommended Use |
|---|---|---|---|---|---|
| tiny | 39M | ~1GB | ~32x | Basic | Quick tests |
| base | 74M | ~1GB | ~16x | Good | General use |
| small | 244M | ~2GB | ~6x | Very good | Balanced |
| medium | 769M | ~5GB | ~2x | Excellent | High quality |
| large-v3 | 1550M | ~10GB | ~1x | Best | Maximum precision |
Whisper Features:
The Facebook Denoiser uses deep learning for audio enhancement:
PyAnnote represents the reference for speaker diarization:
# AI/ML Libraries
torch>=2.0.0 # PyTorch backend
torchaudio>=2.0.0 # PyTorch audio processing
openai-whisper>=20240930 # Speech recognition
pyannote.audio>=3.1.0 # Speaker diarization
denoiser>=0.1.5 # Facebook audio enhancement
# Audio Processing
librosa>=0.10.0 # Audio analysis
soundfile>=0.12.1 # Audio I/O
scipy>=1.10.0 # Signal processing
# Utilities
numpy>=1.24.0 # Numerical computing
tqdm>=4.65.0 # Progress bars
huggingface_hub>=0.16.0 # Model management
The system implements several design patterns:
class ModelManager:
def get_whisper_model(self, size="base"):
return whisper.load_model(size, device=self.device)
def get_diarization_pipeline(self):
return Pipeline.from_pretrained("pyannote/speaker-diarization-3.1")
class OutputFormatter:
def save_output(self, data, format_type):
if format_type == "json":
return self._save_json(data)
elif format_type == "md":
return self._save_markdown(data)
# ...
def transcription_pipeline(audio_file):
audio = AudioProcessor().process(audio_file)
transcription = Transcriber().transcribe(audio)
diarization = Diarizer().diarize(audio) # optional
OutputFormatter().save(transcription, diarization)
Scenario: Weekly meeting with 4 participants, smartphone recording (M4A format, medium quality).
# Complete transcription with speaker identification
python main.py weekly_meeting.m4a \
-o meeting_2024_05_26 \
--format md \
--model-size medium \
--diarize \
--language en \
--clean-audio
Generated Output (meeting_2024_05_26.md):
# Meeting Transcription
**Date**: 2024-05-26 14:30:00
**Duration**: 47 minutes
**Participants**: 4 speakers identified
## SPEAKER_A (Project Manager)
**00:02:15**: Good morning everyone, let's start with Q2 sales.
## SPEAKER_B (Sales Director)
**00:02:22**: The numbers are very positive, we exceeded our target by 12%.
## SPEAKER_C (Marketing Manager)
**00:02:35**: Excellent result. The digital campaign performed beyond expectations.
Processing Time: ~8 minutes on RTX 4060 Ti GPU
Accuracy: ~94% recognition, ~89% speaker attribution
Scenario: 90-minute radio interview, two speakers, professional WAV audio.
# Maximum quality without audio enhancement (already clean)
python main.py mayor_interview.wav \
-o exclusive_interview \
--format json \
--model-size large-v3 \
--diarize \
--language en
JSON Output Features:
Scenario: 2-hour lecture recording, single speaker (professor), reverberant classroom audio.
# Focus on audio quality for reverberant environment
python main.py quantum_physics_lecture.m4a \
-o lecture_may_26 \
--format txt \
--model-size medium \
--clean-audio \
--language en
Specific Advantages:
Scenario: Podcast with 3 hosts + 2 guests, 75 minutes, exported from streaming platform.
# Complete processing for editorial content
python main.py podcast_episode_142.mp3 \
-o transcribed_podcast \
--format md \
--model-size large-v3 \
--diarize \
--language en \
--log-level DEBUG
Professional Result:
| Audio Duration | Model | Processing Time | Real-time Factor | GPU Memory |
|---|---|---|---|---|
| 5 min | tiny | 0.8 min | 0.16x | 1.2GB |
| 30 min | base | 3.2 min | 0.11x | 1.8GB |
| 60 min | medium | 8.7 min | 0.15x | 3.1GB |
| 90 min | large-v3 | 28.4 min | 0.32x | 3.8GB |
| Audio Type | Model | WER (%) | Speaker Accuracy (%) |
|---|---|---|---|
| Meeting | medium + diarization | 8.2% | 91.3% |
| Interview | large-v3 + diarization | 4.7% | 96.8% |
| Lecture | medium + enhancement | 6.1% | N/A |
| Podcast | large-v3 + diarization | 5.4% | 89.7% |
Minimum Hardware:
Recommended Hardware:
# Clone repository
git clone https://github.com/username/audio-transcription-tool
cd audio-transcription-tool
# Setup Python 3.11 environment (recommended)
python -m venv venv
source venv/bin/activate # Linux/macOS
# venv\Scripts\activate # Windows
# Install dependencies
pip install --upgrade pip
pip install -r requirements.txt
# Test installation
python main.py --help
# For NVIDIA GPU with CUDA
pip install torch torchaudio --index-url https://download.pytorch.org/whl/cu118
# Verify CUDA
python -c "import torch; print(f'CUDA: {torch.cuda.is_available()})"
# Configure token
export HUGGINGFACE_HUB_TOKEN="your_token_here"
# Download models
python -c "from pyannote.audio import Pipeline; Pipeline.from_pretrained('pyannote/speaker-diarization-3.1')"
For processing multiple audio files:
#!/usr/bin/env python3
"""Batch processing script"""
import glob
import subprocess
from pathlib import Path
def batch_transcribe(input_dir, output_dir, **kwargs):
"""Process all audio files in directory"""
audio_files = glob.glob(f"{input_dir}/*.{wav,mp3,m4a}")
for audio_file in audio_files:
output_name = Path(audio_file).stem
output_path = f"{output_dir}/{output_name}"
cmd = [
"python", "main.py", audio_file,
"-o", output_path,
"--format", kwargs.get("format", "md"),
"--model-size", kwargs.get("model", "medium")
]
if kwargs.get("diarize"):
cmd.append("--diarize")
subprocess.run(cmd)
# Usage
batch_transcribe(
input_dir="./audio_files",
output_dir="./transcripts",
format="json",
model="large-v3",
diarize=True
)
Flask wrapper for API usage:
from flask import Flask, request, jsonify
import tempfile
import os
app = Flask(__name__)
@app.route('/transcribe', methods=['POST'])
def transcribe_api():
"""API endpoint for transcription"""
if 'audio' not in request.files:
return jsonify({"error": "No audio file"}), 400
file = request.files['audio']
# Save temporary file
with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tmp:
file.save(tmp.name)
# Process transcription
result = transcriber.transcribe(
tmp.name,
model_size=request.form.get('model', 'base'),
language=request.form.get('language', 'auto')
)
# Cleanup
os.unlink(tmp.name)
return jsonify(result)
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)
WordPress plugin integration:
<?php
/**
* WordPress Audio Transcription Plugin
*/
function transcribe_audio_attachment($attachment_id) {
$file_path = get_attached_file($attachment_id);
// Call Python transcription system
$output = shell_exec("python /path/to/main.py '$file_path' -o /tmp/transcript --format json");
$transcript = json_decode(file_get_contents('/tmp/transcript.json'), true);
// Save as post meta
update_post_meta($attachment_id, '_transcript', $transcript['text']);
update_post_meta($attachment_id, '_speakers', $transcript['speakers']);
return $transcript;
}
// Hook into media upload
add_action('add_attachment', 'transcribe_audio_attachment');
For very long audio files (>2 hours):
def chunk_processing(audio_file, chunk_duration=600): # 10 minutes
"""Process long audio in chunks"""
audio, sr = librosa.load(audio_file, sr=None)
chunk_samples = chunk_duration * sr
transcripts = []
for i in range(0, len(audio), chunk_samples):
chunk = audio[i:i+chunk_samples]
# Process chunk
chunk_transcript = transcriber.transcribe_chunk(chunk, sr)
transcripts.append(chunk_transcript)
# Memory cleanup
torch.cuda.empty_cache()
return merge_transcripts(transcripts)
| Scenario | Model | Enhancement | Diarization | Time | Quality |
|---|---|---|---|---|---|
| Quick draft | tiny | No | No | 0.1x | 85% |
| General use | base | Yes | No | 0.15x | 92% |
| High quality | medium | Yes | Yes | 0.25x | 96% |
| Maximum precision | large-v3 | Yes | Yes | 0.4x | 98% |
Hardware Costs:
vs Cloud Services:
Break-even: ~1,200 hours processed audio
Q3 2024:
Q4 2024:
Q1 2025:
Improvement Areas:
The audio transcription system presented represents a complete and professional solution for large-scale audio-to-text conversion. The modular architecture, use of cutting-edge AI models, and complete offline autonomy make it ideal for both personal use and enterprise deployment.
Implementing this system can significantly transform the workflows of organizations handling large volumes of audio content:
The future of transcription is already here: completely automated, incredibly accurate, and finally accessible to everyone.
Complete code available: GitHub Repository