AI Speech-to-Text on Linux - Complete Guide

		# Install Python and pip if not already installed
sudo pacman -S python python-pip  # Arch
sudo apt install python3 python3-pip  # Ubuntu/Debian
 
# Install ffmpeg for audio processing
sudo pacman -S ffmpeg  # Arch
sudo apt install ffmpeg  # Ubuntu/Debian
 
# Install Whisper
pip install -U openai-whisper
	

		# Transcribe an audio file
whisper audio.mp3
 
# Specify model size (tiny, base, small, medium, large, turbo)
whisper audio.mp3 --model medium
 
# Output to specific format
whisper audio.mp3 --output_format txt
 
# Transcribe with timestamps
whisper audio.mp3 --output_format srt
 
# Specify language for better accuracy
whisper audio.mp3 --language English
 
# Translate to English
whisper audio.mp3 --task translate
	

		import whisper
 
# Load model
model = whisper.load_model("turbo")
 
# Transcribe
result = model.transcribe("audio.mp3")
 
# Print result
print(result["text"])
 
# Get detailed segments with timestamps
for segment in result["segments"]:
    print(f"[{segment['start']:.2f}s -> {segment['end']:.2f}s] {segment['text']}")
	

		import vosk
import whisper
import asyncio
import Levenshtein
from vosk import KaldiRecognizer
 
class HybridTranscriber:
    def __init__(self):
        # Initialize Vosk for real-time
        self.vosk_model = vosk.Model("vosk-model-small-en-us")
        self.recognizer = KaldiRecognizer(self.vosk_model, 16000)
        
        # Initialize Whisper for accuracy checking
        self.whisper_model = whisper.load_model("base")
        
        # Audio buffer for Whisper
        self.audio_buffer = []
        self.correction_delay = 2.0  # seconds
        
    async def transcribe_with_corrections(self, audio_stream):
        vosk_text = ""
        whisper_corrections = []
        
        # Start both transcription processes
        vosk_task = asyncio.create_task(self._vosk_transcribe(audio_stream))
        whisper_task = asyncio.create_task(self._whisper_correct(audio_stream))
        
        # Process results
        while True:
            vosk_result = await vosk_task
            whisper_result = await whisper_task
            
            if vosk_result:
                vosk_text += vosk_result
                print(f"VOSK: {vosk_result}")
            
            if whisper_result:
                # Check if correction is needed
                distance = Levenshtein.distance(vosk_text[-len(whisper_result):], whisper_result)
                if distance > len(whisper_result) * 0.3:  # 30% difference threshold
                    print(f"WHISPER CORRECTION: {vosk_result} -> {whisper_result}")
                    vosk_text = vosk_text[:-len(vosk_result)] + whisper_result
    
    async def _vosk_transcribe(self, audio_stream):
        # Real-time Vosk transcription
        while True:
            data = await audio_stream.read(4000)
            if self.recognizer.AcceptWaveform(data):
                result = json.loads(self.recognizer.Result())
                return result["text"]
    
    async def _whisper_correct(self, audio_stream):
        # Background Whisper correction
        await asyncio.sleep(self.correction_delay)
        # Process accumulated audio with Whisper
        result = self.whisper_model.transcribe("temp_audio.wav")
        return result["text"]
	

		import whisper
import pyaudio
import wave
import tempfile
import os
 
model = whisper.load_model("base")
 
# Audio recording parameters
CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 16000
RECORD_SECONDS = 5
 
def record_audio():
    p = pyaudio.PyAudio()
    stream = p.open(format=FORMAT,
                    channels=CHANNELS,
                    rate=RATE,
                    input=True,
                    frames_per_buffer=CHUNK)
 
    print("Recording...")
    frames = []
 
    for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
        data = stream.read(CHUNK)
        frames.append(data)
 
    print("Finished recording.")
    stream.stop_stream()
    stream.close()
    p.terminate()
 
    return frames
 
def transcribe_audio(frames):
    # Save to temporary file
    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_audio:
        wf = wave.open(temp_audio.name, 'wb')
        wf.setnchannels(CHANNELS)
        wf.setsampwidth(pyaudio.PyAudio().get_sample_size(FORMAT))
        wf.setframerate(RATE)
        wf.writeframes(b''.join(frames))
        wf.close()
 
        # Transcribe
        result = model.transcribe(temp_audio.name)
        os.unlink(temp_audio.name)
 
        return result["text"]
 
# Main loop
while True:
    input("Press Enter to start recording...")
    frames = record_audio()
    text = transcribe_audio(frames)
    print(f"Transcription: {text}\n")
	

		# Install
pip install faster-whisper
 
# Usage
from faster_whisper import WhisperModel
 
model = WhisperModel("base", device="cpu", compute_type="int8")
 
segments, info = model.transcribe("audio.mp3", beam_size=5)
 
for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")
	

		# Clone and build
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp
make
 
# Download models
bash ./models/download-ggml-model.sh base
 
# Transcribe
./main -m models/ggml-base.bin -f audio.wav
	

		# Install
pip install vosk
 
# Download models from https://alphacephei.com/vosk/models
wget https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip
unzip vosk-model-small-en-us-0.15.zip
	

		from vosk import Model, KaldiRecognizer
import wave
import json
 
model = Model("vosk-model-small-en-us-0.15")
wf = wave.open("audio.wav", "rb")
rec = KaldiRecognizer(model, wf.getframerate())
 
while True:
    data = wf.readframes(4000)
    if len(data) == 0:
        break
    if rec.AcceptWaveform(data):
        result = json.loads(rec.Result())
        print(result["text"])
 
# Final result
print(json.loads(rec.FinalResult())["text"])
	

		pip install transformers torch
	

		from transformers import pipeline
 
# Load Whisper model
transcriber = pipeline("automatic-speech-recognition",
                      model="openai/whisper-large-v3")
 
# Transcribe
result = transcriber("audio.mp3")
print(result["text"])
 
# With language specification
result = transcriber("audio.mp3",
                     generate_kwargs={"language": "english"})
	

		# Create script at ~/bin/transcribe
#!/bin/bash
 
if [ -z "$1" ]; then
    echo "Usage: transcribe <audio-file>"
    exit 1
fi
 
whisper "$1" --model base --output_format txt --output_dir "$(dirname "$1")"
	

		# Make executable
chmod +x ~/bin/transcribe
 
# Add to PATH (add to ~/.bashrc or ~/.zshrc)
export PATH="$HOME/bin:$PATH"
 
# Usage
transcribe recording.mp3
	

		#!/bin/bash
# ~/bin/voice-note
 
RECORDINGS_DIR="$HOME/voice-notes"
mkdir -p "$RECORDINGS_DIR"
 
FILENAME="$RECORDINGS_DIR/note-$(date +%Y%m%d-%H%M%S).wav"
 
# Record audio
arecord -f cd -d 10 "$FILENAME"
 
# Transcribe
whisper "$FILENAME" --model base --output_format txt
 
# Show notification
notify-send "Voice Note" "Transcription complete!"
	

		# Install PyTorch with CUDA
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
 
# Whisper will automatically use GPU if available
whisper audio.mp3 --model large  # Will use GPU
	

		# Record meeting
arecord -f cd -d 3600 meeting.wav
 
# Transcribe with timestamps
whisper meeting.wav --output_format srt --model medium
	

		# Download audio with yt-dlp
yt-dlp -x --audio-format mp3 "VIDEO_URL"
 
# Transcribe
whisper "video.mp3" --model base
	

		# Batch transcribe all podcast episodes
for file in podcasts/*.mp3; do
    whisper "$file" --model small --output_format txt
done
	

		# Use smaller model
whisper audio.mp3 --model tiny
 
# Or use faster-whisper with int8
	

		# Specify language
whisper audio.mp3 --language English --model medium
 
# Use larger model
whisper audio.mp3 --model large
	

		# Use whisper.cpp or faster-whisper
# Enable GPU acceleration
# Use smaller model
	

		# Install required packages
pip install datasets transformers accelerate
 
# Prepare your dataset (audio-text pairs)
# Then fine-tune
from transformers import WhisperForConditionalGeneration, WhisperProcessor
from datasets import load_dataset
 
# Load pre-trained model
model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-base")
processor = WhisperProcessor.from_pretrained("openai/whisper-base")
 
# Fine-tune on custom dataset
# (Implementation details depend on your specific use case)
	

		# Install pyannote.audio for speaker diarization
pip install pyannote.audio
 
# Usage example
from pyannote.audio import Pipeline
from pyannote.core import Segment, Annotation
 
# Initialize speaker diarization pipeline
pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization")
 
# Process audio
diarization = pipeline("meeting.wav")
 
# Combine with Whisper transcription
# (Implementation would merge speaker segments with transcribed text)
	

		import asyncio
import websockets
import json
from faster_whisper import WhisperModel
 
class StreamingTranscriber:
    def __init__(self):
        self.model = WhisperModel("base", device="cpu", compute_type="int8")
        self.audio_buffer = []
        self.buffer_duration = 30  # seconds
        
    async def transcribe_stream(self, websocket):
        async for message in websocket:
            # Receive audio chunks
            audio_chunk = json.loads(message)["audio"]
            self.audio_buffer.append(audio_chunk)
            
            # Process when buffer is full
            if len(self.audio_buffer) >= self.buffer_duration * 16:  # 16kHz sample rate
                segments, _ = self.model.transcribe(
                    self._buffer_to_audio(),
                    language="en",
                    beam_size=5,
                    vad_filter=True
                )
                
                # Send transcription back
                for segment in segments:
                    await websocket.send(json.dumps({
                        "text": segment.text,
                        "start": segment.start,
                        "end": segment.end
                    }))
                
                self.audio_buffer = []  # Clear buffer
	

		# Normalize audio levels before transcription
sox input.wav output.wav norm
 
# Remove silence
sox input.wav output.wav silence 1 0.1 1% reverse silence 1 0.1 1% reverse
 
# Convert sample rate
sox input.wav -r 16000 output.wav
 
# Chain with Whisper
sox input.wav -r 16000 - | whisper - --model base
	

		# Add to crontab for daily transcription of recorded files
# crontab -e
# 0 2 * * * /home/user/transcribe_daily.sh
 
#!/bin/bash
# transcribe_daily.sh
RECORDINGS_DIR="/home/user/recordings"
OUTPUT_DIR="/home/user/transcripts"
 
for file in "$RECORDINGS_DIR"/*.wav; do
    if [ -f "$file" ]; then
        filename=$(basename "$file" .wav)
        whisper "$file" --model base --output_dir "$OUTPUT_DIR" --output_format txt
        mv "$file" "${RECORDINGS_DIR}/processed/"
    fi
done