feat: Add advanced hallucination detection and confidence scoring system

- Created whisper/enhancements module for enhanced functionality
- Implemented HallucinationDetector with multi-method detection:
  * Pattern-based detection (YouTube artifacts, repetitive phrases)
  * Statistical analysis (compression ratios, log probabilities)
  * Repetition analysis (looping behavior detection)
  * Temporal analysis (silence-based detection)
- Added ConfidenceScorer for comprehensive transcription quality assessment
- Enhanced transcribe() function with new parameters:
  * enhanced_hallucination_detection: Enable advanced detection
  * hallucination_detection_language: Language-specific patterns
  * strict_hallucination_filtering: Strict vs permissive filtering
  * confidence_threshold: Minimum confidence for segments
- Maintains full backward compatibility
- Added CLI arguments for new functionality

Addresses: OpenAI Whisper Discussion #679 - Hallucinations & Repetition Loops

CLAUDE.md

@@ -0,0 +1,123 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+OpenAI Whisper is a robust automatic speech recognition (ASR) system built on a Transformer sequence-to-sequence model. It performs multilingual speech recognition, speech translation, spoken language identification, and voice activity detection as a unified multitask model.
+
+## Development Commands
+
+### Installation
+```bash
+# Install package in development mode with dependencies
+pip install -e ".[dev]"
+
+# Or install from requirements
+pip install -r requirements.txt
+```
+
+### Code Quality & Linting
+```bash
+# Format code with black
+black .
+
+# Sort imports with isort
+isort .
+
+# Lint with flake8
+flake8
+
+# Run all pre-commit hooks
+pre-commit run --all-files
+```
+
+### Testing
+```bash
+# Run all tests
+pytest
+
+# Run tests with verbose output
+pytest -v
+
+# Run specific test file
+pytest tests/test_transcribe.py
+
+# Run tests requiring CUDA
+pytest -m requires_cuda
+```
+
+### Package Building
+```bash
+# Build package
+python -m build
+
+# Install built package
+pip install dist/openai_whisper-*.whl
+```
+
+## Architecture Overview
+
+### Core Components
+
+**whisper/__init__.py**: Main entry point with model loading (`load_model()`) and model registry (`_MODELS` dict mapping model names to download URLs)
+
+**whisper/model.py**:
+- `ModelDimensions`: Configuration dataclass for model architecture
+- `Whisper`: Main model class implementing the Transformer architecture
+- Audio encoder and text decoder components with multi-head attention
+- Optimized layers (`LayerNorm`, `Linear`) for mixed-precision training
+
+**whisper/transcribe.py**:
+- `transcribe()`: High-level transcription function with sliding window processing
+- `cli()`: Command-line interface implementation
+- Handles batch processing, temperature sampling, and output formatting
+
+**whisper/decoding.py**:
+- `DecodingOptions`/`DecodingResult`: Configuration and result classes
+- `decode()`: Core decoding logic with beam search and sampling strategies
+- `detect_language()`: Language identification functionality
+
+**whisper/audio.py**: Audio preprocessing utilities including mel-spectrogram computation, padding/trimming to 30-second windows
+
+**whisper/tokenizer.py**: BPE tokenization with special tokens for task specification (transcription vs translation) and language identification
+
+**whisper/timing.py**: Word-level timestamp alignment using cross-attention weights from specific attention heads
+
+**whisper/normalizers/**: Text normalization for different languages to improve transcription accuracy
+
+### Model Pipeline Flow
+
+1. Audio → Mel-spectrogram (whisper/audio.py)
+2. Spectrogram → Audio encoder features (whisper/model.py)
+3. Language detection via decoder (whisper/decoding.py)
+4. Text generation with task-specific tokens (whisper/transcribe.py)
+5. Optional word-level timestamp alignment (whisper/timing.py)
+
+### Available Models
+
+Six model sizes with different accuracy/speed tradeoffs:
+- `tiny`, `base`, `small`, `medium`, `large`, `turbo`
+- English-only variants: `*.en` (better for English)
+- Models auto-download to `~/.cache/whisper/`
+
+## Testing Structure
+
+- **tests/conftest.py**: pytest configuration with CUDA markers and random seeds
+- **tests/jfk.flac**: Reference audio file for integration tests
+- Tests cover audio processing, tokenization, normalization, timing, and transcription functionality
+
+## Code Style
+
+- **Black** formatter (88 char line length)
+- **isort** for import sorting (black profile)
+- **flake8** linting with specific ignores for E203, E501, W503, W504
+- **pre-commit hooks** enforce consistency
+
+## Key Dependencies
+
+- **PyTorch**: Core ML framework
+- **tiktoken**: Fast BPE tokenization
+- **numba**: JIT compilation for audio processing
+- **tqdm**: Progress bars for model downloads and processing
+- **triton**: GPU kernel optimization (Linux x86_64)

REPOSITORY_ISSUES_ANALYSIS.md

@@ -0,0 +1,647 @@
+# OpenAI Whisper Repository Issues Analysis
+
+This document analyzes the top 5 most critical issues identified from the OpenAI Whisper repository discussions, commit history, and community reports. The analysis is based on actual GitHub discussions, bug fix commits, and user-reported problems.
+
+## Issue #1: Hallucinations and Repetition Loops
+
+### **Severity**: CRITICAL
+### **Discussion References**: #679 (184 comments), commit 919a713, ba3f3cd, 38f2f4d
+### **Impact**: High - Creates "ghost transcripts" and repetitive text
+
+### Problem Description
+Whisper creates false transcripts, especially at the end of audio files or after long silent gaps. The model gets stuck in repetition loops, particularly affecting Norwegian and German audio on medium/large models.
+
+### Root Cause Analysis
+- **Context Contamination**: The `condition_on_previous_text=True` parameter causes problems when the last chunk is short compared to previous context
+- **Silent Gaps**: Long periods without speech (50+ minutes) cause the model to loop on the last spoken segment
+- **Chunk Boundary Issues**: Problems arise at chunk transitions, especially in the final segments
+
+### Solution Process
+
+#### Immediate Fix - Lucid Whisper Approach
+```python
+# Implementation from Discussion #679
+# whisper/transcribe.py - Replace line 178
+
+def apply_lucid_whisper_fix(decode_options, all_tokens, prompt_reset_since,
+                           seek, num_frames, N_FRAMES):
+    """
+    Prevents hallucinations by controlling context based on chunk position
+    """
+    lucid_threshold = 0.3  # Threshold for permissible chunk length
+
+    if ((seek + N_FRAMES) / num_frames < 1.0) or (seek == 0):
+        # First chunk or next chunk fully within frames - safe to use context
+        decode_options["prompt"] = all_tokens[prompt_reset_since:]
+    else:
+        # Last chunk - calculate lucid score to decide context usage
+        lucid_score = (num_frames - seek) / N_FRAMES
+        if lucid_score < lucid_threshold and "prompt" in decode_options:
+            # Lucid Score below threshold - erase context to prevent hallucination
+            decode_options["prompt"] = []
+        else:
+            # Lucid Score above threshold - keep context
+            decode_options["prompt"] = all_tokens[prompt_reset_since:]
+
+    return decode_options
+```
+
+#### VAD-based Solution
+```python
+# Voice Activity Detection approach from Discussion #679
+import torch
+import torchaudio
+
+def preprocess_with_vad(audio_path):
+    """
+    Remove silent segments before transcription to prevent hallucinations
+    """
+    waveform, sample_rate = torchaudio.load(audio_path)
+
+    # Use torchaudio's VAD (Voice Activity Detection)
+    model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad',
+                                  model='silero_vad',
+                                  force_reload=True)
+
+    (get_speech_timestamps,
+     save_audio,
+     read_audio,
+     VADIterator,
+     collect_chunks) = utils
+
+    # Get speech timestamps
+    speech_timestamps = get_speech_timestamps(waveform, model,
+                                            sampling_rate=sample_rate)
+
+    # Extract only speech segments
+    if speech_timestamps:
+        speech_audio = collect_chunks(speech_timestamps, waveform)
+        return speech_audio
+    else:
+        return waveform
+
+# Usage in transcription
+def transcribe_with_vad(model, audio_path):
+    clean_audio = preprocess_with_vad(audio_path)
+    result = model.transcribe(clean_audio, condition_on_previous_text=False)
+    return result
+```
+
+---
+
+## Issue #2: Real-time Streaming and Performance Limitations
+
+### **Severity**: HIGH
+### **Discussion References**: #2 (92 comments), #937 (131 comments)
+### **Impact**: Medium-High - Prevents real-time applications
+
+### Problem Description
+Whisper's architecture isn't designed for real-time streaming tasks. Users need websocket integration for streaming PCM data, but the 30-second window requirement makes this challenging.
+
+### Root Cause Analysis
+- **Fixed Window Size**: Whisper processes 30-second chunks, not suitable for streaming
+- **Model Architecture**: Encoder-decoder architecture requires complete audio segments
+- **Memory Requirements**: Large models need significant GPU memory for real-time processing
+
+### Solution Process
+
+#### CTranslate2 Acceleration (from Discussion #937)
+```python
+# Accelerated Whisper with CTranslate2
+import ctranslate2
+import faster_whisper
+
+def setup_fast_whisper():
+    """
+    Setup accelerated Whisper for better real-time performance
+    """
+    # Use faster-whisper with CTranslate2 backend
+    model = faster_whisper.WhisperModel("large-v2", device="cuda", compute_type="float16")
+    return model
+
+def streaming_transcribe(model, audio_stream, chunk_duration=5):
+    """
+    Pseudo-streaming by processing shorter chunks
+    """
+    buffer = []
+    results = []
+
+    for audio_chunk in audio_stream:
+        buffer.append(audio_chunk)
+
+        # Process when we have enough audio
+        if len(buffer) >= chunk_duration * 16000:  # 16kHz sample rate
+            audio_data = np.concatenate(buffer)
+            segments, info = model.transcribe(audio_data, beam_size=1)
+
+            for segment in segments:
+                results.append(segment.text)
+                yield segment.text  # Stream results
+
+            # Keep overlap for context
+            overlap_samples = int(1 * 16000)  # 1 second overlap
+            buffer = [audio_data[-overlap_samples:]]
+
+    return results
+```
+
+#### WebSocket Integration
+```python
+# Real-time WebSocket handler
+import asyncio
+import websockets
+import json
+import numpy as np
+
+class WhisperWebSocketServer:
+    def __init__(self, model):
+        self.model = model
+        self.audio_buffer = np.array([], dtype=np.float32)
+
+    async def handle_audio_stream(self, websocket, path):
+        """
+        Handle streaming audio from WebSocket
+        """
+        try:
+            async for message in websocket:
+                data = json.loads(message)
+
+                if data['type'] == 'audio':
+                    # Decode PCM data
+                    audio_data = np.array(data['audio'], dtype=np.float32)
+                    self.audio_buffer = np.concatenate([self.audio_buffer, audio_data])
+
+                    # Process if buffer is large enough (5 seconds)
+                    if len(self.audio_buffer) >= 5 * 16000:
+                        result = await self.process_chunk(self.audio_buffer)
+                        await websocket.send(json.dumps({
+                            'type': 'transcription',
+                            'text': result
+                        }))
+
+                        # Keep 1 second overlap
+                        self.audio_buffer = self.audio_buffer[-16000:]
+
+        except websockets.exceptions.ConnectionClosed:
+            pass
+
+    async def process_chunk(self, audio_data):
+        """
+        Process audio chunk asynchronously
+        """
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(
+            None, self.model.transcribe, audio_data
+        )
+        return result['text']
+
+# Start WebSocket server
+def start_streaming_server():
+    model = setup_fast_whisper()
+    server = WhisperWebSocketServer(model)
+
+    start_server = websockets.serve(
+        server.handle_audio_stream, "localhost", 8765
+    )
+
+    asyncio.get_event_loop().run_until_complete(start_server)
+    asyncio.get_event_loop().run_forever()
+```
+
+---
+
+## Issue #3: Fine-tuning and Training Code Unavailability
+
+### **Severity**: MEDIUM-HIGH
+### **Discussion References**: #64 (113 comments), #759 (79 comments)
+### **Impact**: High - Limits model customization
+
+### Problem Description
+OpenAI hasn't released the training code for Whisper models, preventing users from fine-tuning for specific domains, languages, or use cases.
+
+### Root Cause Analysis
+- **Proprietary Training Pipeline**: OpenAI maintains training code internally
+- **Dataset Dependencies**: Training requires massive multilingual datasets
+- **Computational Requirements**: Training requires significant computational resources
+
+### Solution Process
+
+#### Community Fine-tuning Framework
+```python
+# Fine-tuning setup using Hugging Face transformers
+from transformers import (
+    WhisperProcessor,
+    WhisperForConditionalGeneration,
+    TrainingArguments,
+    Trainer
+)
+import torch
+from torch.utils.data import Dataset
+
+class WhisperDataset(Dataset):
+    def __init__(self, audio_files, transcriptions, processor):
+        self.audio_files = audio_files
+        self.transcriptions = transcriptions
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.audio_files)
+
+    def __getitem__(self, idx):
+        audio = whisper.load_audio(self.audio_files[idx])
+        audio = whisper.pad_or_trim(audio)
+
+        # Process audio
+        input_features = self.processor(
+            audio, sampling_rate=16000, return_tensors="pt"
+        ).input_features[0]
+
+        # Process transcription
+        labels = self.processor.tokenizer(
+            self.transcriptions[idx],
+            return_tensors="pt"
+        ).input_ids[0]
+
+        return {
+            "input_features": input_features,
+            "labels": labels
+        }
+
+def setup_fine_tuning():
+    """
+    Setup fine-tuning environment for domain-specific adaptation
+    """
+    # Load pre-trained model
+    processor = WhisperProcessor.from_pretrained("openai/whisper-small")
+    model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-small")
+
+    # Training arguments
+    training_args = TrainingArguments(
+        output_dir="./whisper-finetuned",
+        per_device_train_batch_size=4,
+        gradient_accumulation_steps=2,
+        warmup_steps=500,
+        max_steps=5000,
+        learning_rate=1e-5,
+        fp16=True,
+        evaluation_strategy="steps",
+        eval_steps=500,
+        save_steps=1000,
+        logging_steps=25,
+    )
+
+    return processor, model, training_args
+
+def fine_tune_whisper(audio_files, transcriptions):
+    """
+    Fine-tune Whisper on custom dataset
+    """
+    processor, model, training_args = setup_fine_tuning()
+
+    # Create dataset
+    dataset = WhisperDataset(audio_files, transcriptions, processor)
+
+    # Initialize trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=dataset,
+        tokenizer=processor.feature_extractor,
+    )
+
+    # Start fine-tuning
+    trainer.train()
+
+    # Save fine-tuned model
+    trainer.save_model()
+    return model
+```
+
+#### Domain Adaptation Strategy
+```python
+# Domain-specific adaptation without full retraining
+def create_domain_adapter():
+    """
+    Create adapter layers for domain-specific fine-tuning
+    """
+    import torch.nn as nn
+
+    class WhisperAdapter(nn.Module):
+        def __init__(self, original_model, adapter_dim=64):
+            super().__init__()
+            self.original_model = original_model
+            self.adapter_dim = adapter_dim
+
+            # Add adapter layers
+            self.adapters = nn.ModuleDict()
+            for name, module in original_model.named_modules():
+                if isinstance(module, nn.Linear):
+                    self.adapters[name] = nn.Sequential(
+                        nn.Linear(module.in_features, adapter_dim),
+                        nn.ReLU(),
+                        nn.Linear(adapter_dim, module.out_features)
+                    )
+
+        def forward(self, *args, **kwargs):
+            # Apply adapters during forward pass
+            return self.original_model(*args, **kwargs)
+
+    return WhisperAdapter
+```
+
+---
+
+## Issue #4: Memory Issues and Model Performance
+
+### **Severity**: MEDIUM
+### **Discussion References**: #5 (25 comments), commit analysis
+### **Impact**: Medium - Affects scalability
+
+### Problem Description
+Large Whisper models consume significant GPU memory, and processing long audio files can cause memory overflow or slow performance.
+
+### Root Cause Analysis
+- **Model Size**: Large models require 10GB+ VRAM
+- **Batch Processing**: Memory accumulates with long audio files
+- **Inefficient Caching**: Attention caches grow with sequence length
+
+### Solution Process
+
+#### Memory-Efficient Processing
+```python
+def memory_efficient_transcribe(model, audio_path, max_memory_mb=4000):
+    """
+    Process large audio files with memory constraints
+    """
+    import psutil
+    import gc
+
+    audio = whisper.load_audio(audio_path)
+    duration = len(audio) / 16000  # seconds
+
+    # Calculate optimal chunk size based on available memory
+    available_memory = psutil.virtual_memory().available / (1024 * 1024)  # MB
+    safe_memory = min(max_memory_mb, available_memory * 0.7)  # Use 70% of available
+
+    # Estimate chunk duration based on memory
+    chunk_duration = min(30, max(10, safe_memory / 200))  # Heuristic
+    chunk_samples = int(chunk_duration * 16000)
+
+    results = []
+    for i in range(0, len(audio), chunk_samples):
+        chunk = audio[i:i + chunk_samples]
+
+        # Clear memory before processing
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        gc.collect()
+
+        # Process chunk
+        result = model.transcribe(chunk, fp16=False)  # Use fp32 for stability
+        results.append(result['text'])
+
+        print(f"Processed {i//chunk_samples + 1}/{(len(audio)-1)//chunk_samples + 1}")
+
+    return ' '.join(results)
+
+# Memory monitoring
+def monitor_memory_usage():
+    """
+    Monitor memory usage during transcription
+    """
+    import psutil
+
+    process = psutil.Process()
+    memory_info = process.memory_info()
+
+    print(f"RSS Memory: {memory_info.rss / 1024 / 1024:.1f} MB")
+    print(f"VMS Memory: {memory_info.vms / 1024 / 1024:.1f} MB")
+
+    if torch.cuda.is_available():
+        gpu_memory = torch.cuda.memory_allocated()
+        gpu_cached = torch.cuda.memory_reserved()
+        print(f"GPU Memory: {gpu_memory / 1024 / 1024:.1f} MB")
+        print(f"GPU Cached: {gpu_cached / 1024 / 1024:.1f} MB")
+```
+
+#### Model Optimization
+```python
+def optimize_model_for_memory(model):
+    """
+    Optimize model for lower memory usage
+    """
+    # Use gradient checkpointing
+    model.model.encoder.gradient_checkpointing = True
+    model.model.decoder.gradient_checkpointing = True
+
+    # Enable mixed precision
+    if torch.cuda.is_available():
+        model = model.half()
+
+    # Optimize attention
+    try:
+        from torch.nn.functional import scaled_dot_product_attention
+        # Enable flash attention if available
+        torch.backends.cuda.enable_flash_sdp(True)
+    except:
+        pass
+
+    return model
+```
+
+---
+
+## Issue #5: Language-Specific and Pronunciation Issues
+
+### **Severity**: MEDIUM
+### **Discussion References**: #25 (6 comments), #16 (13 comments)
+### **Impact**: Medium - Affects non-English users
+
+### Problem Description
+Whisper struggles with specific languages (Chinese variants, Serbo-Croatian), pronunciation variations, and code-switching scenarios.
+
+### Root Cause Analysis
+- **Training Data Imbalance**: Less representation for some languages
+- **Dialect Variations**: Similar languages treated as single categories
+- **Phonetic Similarities**: Confusion between related languages
+
+### Solution Process
+
+#### Language-Specific Processing
+```python
+def language_aware_transcribe(model, audio_path, target_language=None):
+    """
+    Enhanced transcription with language-specific optimizations
+    """
+    audio = whisper.load_audio(audio_path)
+
+    # Language detection with confidence
+    mel = whisper.log_mel_spectrogram(audio, n_mels=model.dims.n_mels).to(model.device)
+    _, probs = model.detect_language(mel)
+
+    if target_language is None:
+        # Use detected language
+        detected_lang = max(probs, key=probs.get)
+        confidence = probs[detected_lang]
+
+        if confidence < 0.7:
+            # Low confidence - try multiple languages
+            return multi_language_transcribe(model, audio, probs)
+
+        target_language = detected_lang
+
+    # Language-specific parameters
+    lang_config = get_language_config(target_language)
+
+    result = model.transcribe(
+        audio,
+        language=target_language,
+        **lang_config
+    )
+
+    # Post-process for language-specific corrections
+    result['text'] = apply_language_corrections(result['text'], target_language)
+
+    return result
+
+def get_language_config(language):
+    """
+    Get language-specific transcription parameters
+    """
+    configs = {
+        'zh': {  # Chinese
+            'temperature': 0.0,  # More deterministic
+            'compression_ratio_threshold': 2.8,  # Higher threshold
+            'condition_on_previous_text': False  # Reduce context confusion
+        },
+        'sr': {  # Serbian
+            'temperature': 0.2,
+            'initial_prompt': "Говори јасно.",  # "Speak clearly" in Serbian
+        },
+        'hr': {  # Croatian
+            'temperature': 0.2,
+            'initial_prompt': "Govorite jasno.",  # "Speak clearly" in Croatian
+        },
+        'de': {  # German
+            'temperature': 0.1,
+            'condition_on_previous_text': False,  # Reduce hallucinations
+        }
+    }
+
+    return configs.get(language, {})
+
+def apply_language_corrections(text, language):
+    """
+    Apply language-specific post-processing corrections
+    """
+    corrections = {
+        'zh': [
+            # Chinese-specific corrections
+            ('，', ', '),
+            ('。', '. '),
+            ('？', '? '),
+            ('！', '! ')
+        ],
+        'de': [
+            # German-specific corrections
+            (' ß ', 'ß'),
+            (' ä ', 'ä'),
+            (' ö ', 'ö'),
+            (' ü ', 'ü')
+        ]
+    }
+
+    if language in corrections:
+        for wrong, correct in corrections[language]:
+            text = text.replace(wrong, correct)
+
+    return text
+```
+
+#### Multi-language Detection
+```python
+def multi_language_transcribe(model, audio, language_probs, threshold=0.1):
+    """
+    Handle audio with multiple languages or uncertain detection
+    """
+    # Get top languages above threshold
+    candidate_languages = {
+        lang: prob for lang, prob in language_probs.items()
+        if prob > threshold
+    }
+
+    results = {}
+
+    for language, prob in candidate_languages.items():
+        try:
+            result = model.transcribe(audio, language=language, temperature=0.0)
+
+            # Calculate quality score
+            quality_score = calculate_transcription_quality(result)
+
+            results[language] = {
+                'text': result['text'],
+                'language_prob': prob,
+                'quality_score': quality_score,
+                'combined_score': prob * quality_score
+            }
+        except Exception as e:
+            print(f"Failed to transcribe in {language}: {e}")
+
+    # Return best result
+    if results:
+        best_language = max(results.keys(), key=lambda x: results[x]['combined_score'])
+        return results[best_language]
+    else:
+        # Fallback to auto-detection
+        return model.transcribe(audio)
+
+def calculate_transcription_quality(result):
+    """
+    Calculate transcription quality heuristics
+    """
+    text = result['text']
+
+    # Basic quality indicators
+    word_count = len(text.split())
+    char_diversity = len(set(text.lower())) / max(len(text), 1)
+
+    # Penalize very short or very long outputs
+    length_score = 1.0
+    if word_count < 3:
+        length_score *= 0.5
+    elif word_count > 200:
+        length_score *= 0.8
+
+    # Reward character diversity
+    diversity_score = min(char_diversity * 2, 1.0)
+
+    return length_score * diversity_score
+```
+
+---
+
+## Summary and Implementation Priorities
+
+### Critical Actions (Week 1)
+1. **Implement hallucination fixes** - Apply Lucid Whisper approach and VAD preprocessing
+2. **Setup memory monitoring** - Implement memory-efficient processing for production use
+
+### High Priority (Week 2-3)
+3. **Real-time optimization** - Integrate CTranslate2 acceleration and streaming capabilities
+4. **Language-specific processing** - Add language detection confidence and post-processing
+
+### Medium Priority (Month 1)
+5. **Fine-tuning framework** - Setup domain adaptation infrastructure
+
+### Repository-Specific Recommendations
+
+Based on the actual issues from the OpenAI Whisper repository:
+
+1. **Monitor Discussion #679** - Stay updated on hallucination solutions from the community
+2. **Implement commits ba3f3cd and 919a713** - These contain official fixes for repetition issues
+3. **Consider CTranslate2 integration** - As suggested in Discussion #937 for better performance
+4. **Use VAD preprocessing** - Multiple discussions recommend this for better accuracy
+5. **Test with problematic languages** - Focus on German, Norwegian, and Chinese variants
+
+This analysis provides actionable solutions based on real user problems and community-developed fixes from the OpenAI Whisper repository.

TOP_5_ISSUES_ANALYSIS.md

@@ -0,0 +1,551 @@
+# Top 5 OpenAI Whisper Issues & Solutions Analysis
+
+This document analyzes the most critical issues affecting OpenAI Whisper users based on community reports, research findings, and technical discussions from 2024-2025.
+
+## Issue #1: Hallucinations and Text Generation Problems
+
+### **Severity**: CRITICAL
+### **Impact**: High - Affects transcription accuracy and reliability
+
+### Problem Description
+Whisper generates fabricated text, especially during silence periods. Research shows hallucinations occur in 80% of transcriptions in some studies, with invented text including inappropriate content, ads, and non-existent speech.
+
+### Root Cause
+- Training data contamination from YouTube videos and internet content
+- Model tendency to generate "typical" endings during silence (e.g., "Thanks for watching", "Subscribe to my channel")
+- Autoregressive nature causes looping behavior
+
+### Solution Process
+
+#### Immediate Mitigation
+```python
+# 1. Pre-process audio to remove silence
+import whisper
+from pydub import AudioSegment
+from pydub.silence import split_on_silence
+
+def preprocess_audio(audio_file):
+    audio = AudioSegment.from_file(audio_file)
+    # Remove silence at start/end
+    audio = audio.strip_silence()
+    # Split on silence and rejoin with minimal gaps
+    chunks = split_on_silence(audio, min_silence_len=500, silence_thresh=-40)
+    processed = AudioSegment.empty()
+    for chunk in chunks:
+        processed += chunk + AudioSegment.silent(duration=100)  # Small gap
+    return processed
+```
+
+#### Detection and Filtering
+```python
+# 2. Implement hallucination detection
+def detect_hallucinations(transcription_text):
+    hallucination_patterns = [
+        "thank you for watching", "subscribe", "like and subscribe",
+        "don't forget to", "please subscribe", "thanks for watching"
+    ]
+
+    confidence_score = 1.0
+    for pattern in hallucination_patterns:
+        if pattern.lower() in transcription_text.lower():
+            confidence_score -= 0.3
+
+    return max(0.0, confidence_score)
+
+# 3. Use multiple temperature settings
+def robust_transcribe(model, audio):
+    results = []
+    temperatures = [0.0, 0.2, 0.4]
+
+    for temp in temperatures:
+        result = model.transcribe(audio, temperature=temp)
+        confidence = detect_hallucinations(result["text"])
+        results.append((result, confidence))
+
+    # Return result with highest confidence
+    return max(results, key=lambda x: x[1])[0]
+```
+
+#### Long-term Solutions
+- Fine-tune models on clean, verified datasets
+- Implement VAD (Voice Activity Detection) preprocessing
+- Use ensemble methods with multiple models
+
+---
+
+## Issue #2: Installation and Dependency Conflicts
+
+### **Severity**: HIGH
+### **Impact**: Medium-High - Blocks users from getting started
+
+### Problem Description
+Users experience various installation failures including Python version conflicts, missing dependencies (setuptools, git), Triton compatibility issues on Windows, and "externally-managed-environment" errors on newer Linux distributions.
+
+### Root Cause
+- Complex dependency chain (torch, tiktoken, numba, triton)
+- Platform-specific requirements
+- Python version compatibility limitations
+- Linux distribution security policies
+
+### Solution Process
+
+#### 1. Environment Setup
+```bash
+# Create isolated environment
+python -m venv whisper_env
+source whisper_env/bin/activate  # Linux/Mac
+# whisper_env\Scripts\activate  # Windows
+
+# Verify Python version (3.8-3.12 supported)
+python --version
+```
+
+#### 2. Platform-Specific Installation
+```bash
+# For most users (recommended)
+pip install -U openai-whisper
+
+# If above fails, install from source
+pip install git+https://github.com/openai/whisper.git
+
+# For Windows with Triton issues
+pip install openai-whisper --no-deps
+pip install torch tqdm more-itertools tiktoken numba numpy
+
+# For Linux with system restrictions
+sudo apt install python3-venv  # Ubuntu/Debian
+python3 -m venv whisper_env
+```
+
+#### 3. Dependency Management Script
+```python
+# setup_whisper.py
+import subprocess
+import sys
+import platform
+
+def install_whisper():
+    # Check Python version
+    version = sys.version_info
+    if not (3, 8) <= (version.major, version.minor) <= (3, 12):
+        print(f"Python {version.major}.{version.minor} not supported. Use 3.8-3.12")
+        return False
+
+    try:
+        # Install system dependencies
+        if platform.system() == "Linux":
+            subprocess.run(["sudo", "apt", "update"], check=True)
+            subprocess.run(["sudo", "apt", "install", "-y", "ffmpeg"], check=True)
+        elif platform.system() == "Darwin":  # macOS
+            subprocess.run(["brew", "install", "ffmpeg"], check=True)
+
+        # Install whisper
+        subprocess.run([sys.executable, "-m", "pip", "install", "-U", "openai-whisper"], check=True)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"Installation failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    install_whisper()
+```
+
+---
+
+## Issue #3: Performance and Memory Issues
+
+### **Severity**: MEDIUM-HIGH
+### **Impact**: High - Affects usability for larger files
+
+### Problem Description
+Whisper can hang or freeze on certain audio files, consume excessive memory with long recordings, and provide inconsistent performance across different audio formats and lengths.
+
+### Root Cause
+- Inefficient memory management with long audio files
+- Lack of proper chunking for large files
+- GPU memory limitations
+- Audio format compatibility issues
+
+### Solution Process
+
+#### 1. Optimized Transcription Function
+```python
+import whisper
+import torch
+from pydub import AudioSegment
+import numpy as np
+
+def optimized_transcribe(model, audio_path, chunk_duration=30):
+    """
+    Transcribe large audio files efficiently using chunking
+    """
+    # Load and preprocess audio
+    audio = AudioSegment.from_file(audio_path)
+
+    # Convert to mono if stereo
+    if audio.channels > 1:
+        audio = audio.set_channels(1)
+
+    # Resample to 16kHz if needed
+    if audio.frame_rate != 16000:
+        audio = audio.set_frame_rate(16000)
+
+    # Process in chunks
+    chunk_length = chunk_duration * 1000  # Convert to milliseconds
+    chunks = [audio[i:i + chunk_length] for i in range(0, len(audio), chunk_length)]
+
+    transcriptions = []
+    for i, chunk in enumerate(chunks):
+        print(f"Processing chunk {i+1}/{len(chunks)}")
+
+        # Convert to numpy array
+        audio_np = np.array(chunk.get_array_of_samples()).astype(np.float32) / 32768.0
+
+        # Clear GPU memory
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+        result = model.transcribe(audio_np, fp16=False)  # Use fp16=False for stability
+        transcriptions.append(result["text"])
+
+    return " ".join(transcriptions)
+
+# Usage with memory monitoring
+def monitor_memory_usage():
+    if torch.cuda.is_available():
+        print(f"GPU Memory: {torch.cuda.memory_allocated() / 1e9:.2f} GB")
+
+    import psutil
+    process = psutil.Process()
+    print(f"RAM Usage: {process.memory_info().rss / 1e9:.2f} GB")
+```
+
+#### 2. Performance Optimization Configuration
+```python
+# config.py
+WHISPER_CONFIG = {
+    'model_size': 'base',  # Start with smaller model
+    'device': 'cuda' if torch.cuda.is_available() else 'cpu',
+    'fp16': torch.cuda.is_available(),  # Use mixed precision if available
+    'chunk_duration': 30,  # seconds
+    'temperature': 0.0,  # Deterministic output
+    'compression_ratio_threshold': 2.4,
+    'logprob_threshold': -1.0,
+    'no_speech_threshold': 0.6,
+}
+
+def load_optimized_model(config):
+    model = whisper.load_model(
+        config['model_size'],
+        device=config['device']
+    )
+
+    # Enable optimizations
+    if config['device'] == 'cuda':
+        model.half()  # Use half precision
+
+    return model
+```
+
+---
+
+## Issue #4: Language and Accent Recognition Problems
+
+### **Severity**: MEDIUM
+### **Impact**: Medium - Affects non-English speakers and accented speech
+
+### Problem Description
+Whisper underperforms with heavy accents, rare dialects, and non-English languages. Bias amplification occurs in multilingual contexts, with accuracy degrading significantly for underrepresented languages.
+
+### Root Cause
+- Training data bias toward English and common accents
+- Insufficient representation of diverse languages/dialects
+- Model architecture limitations for code-switching
+
+### Solution Process
+
+#### 1. Language-Specific Optimization
+```python
+def enhanced_multilingual_transcribe(model, audio_path, target_language=None):
+    """
+    Improved transcription for non-English languages
+    """
+    import whisper
+    from whisper.tokenizer import get_tokenizer
+
+    # Load audio
+    audio = whisper.load_audio(audio_path)
+    audio = whisper.pad_or_trim(audio)
+
+    # Make log-Mel spectrogram
+    mel = whisper.log_mel_spectrogram(audio, n_mels=model.dims.n_mels).to(model.device)
+
+    # Detect language if not specified
+    if target_language is None:
+        _, probs = model.detect_language(mel)
+        target_language = max(probs, key=probs.get)
+        print(f"Detected language: {target_language} (confidence: {probs[target_language]:.2f})")
+
+    # Use language-specific decoding options
+    options = whisper.DecodingOptions(
+        language=target_language,
+        task="transcribe",
+        temperature=0.0,  # More deterministic for better accuracy
+        fp16=False  # Better accuracy for non-English
+    )
+
+    result = whisper.decode(model, mel, options)
+    return result.text, target_language
+
+# Language-specific post-processing
+def postprocess_by_language(text, language):
+    """
+    Apply language-specific corrections
+    """
+    corrections = {
+        'es': {  # Spanish
+            ' ñ ': 'ñ',
+            ' á ': 'á',
+            ' é ': 'é',
+            ' í ': 'í',
+            ' ó ': 'ó',
+            ' ú ': 'ú'
+        },
+        'fr': {  # French
+            ' ç ': 'ç',
+            ' à ': 'à',
+            ' è ': 'è',
+            ' é ': 'é',
+            ' ê ': 'ê',
+            ' ë ': 'ë'
+        }
+    }
+
+    if language in corrections:
+        for wrong, correct in corrections[language].items():
+            text = text.replace(wrong, correct)
+
+    return text
+```
+
+#### 2. Accent Adaptation
+```python
+def accent_robust_transcribe(model, audio_path, accent_hint=None):
+    """
+    Transcribe with accent adaptation
+    """
+    # Use multiple temperature settings for robustness
+    temperatures = [0.0, 0.2, 0.4]
+    results = []
+
+    for temp in temperatures:
+        result = model.transcribe(
+            audio_path,
+            temperature=temp,
+            condition_on_previous_text=False,  # Reduce hallucinations
+            word_timestamps=True  # For confidence scoring
+        )
+        results.append(result)
+
+    # Select best result based on consistency and confidence
+    return select_best_transcription(results)
+
+def select_best_transcription(results):
+    """
+    Select the most reliable transcription from multiple attempts
+    """
+    # Simple heuristic: choose result with most consistent word timing
+    best_result = None
+    best_score = 0
+
+    for result in results:
+        if 'segments' in result:
+            # Calculate timing consistency score
+            timing_score = calculate_timing_consistency(result['segments'])
+            if timing_score > best_score:
+                best_score = timing_score
+                best_result = result
+
+    return best_result if best_result else results[0]
+```
+
+---
+
+## Issue #5: Security and Privacy Concerns
+
+### **Severity**: MEDIUM-HIGH
+### **Impact**: High - Critical for enterprise and healthcare use
+
+### Problem Description
+Whisper processes sensitive audio data that may contain private information. Local processing can expose data through logs, temporary files, and memory dumps. Healthcare and enterprise users require HIPAA/GDPR compliance.
+
+### Root Cause
+- Lack of built-in data sanitization
+- Temporary file creation during processing
+- Memory management issues
+- No encryption for stored model weights or cached data
+
+### Solution Process
+
+#### 1. Secure Processing Wrapper
+```python
+import os
+import tempfile
+import shutil
+from pathlib import Path
+import hashlib
+
+class SecureWhisperProcessor:
+    def __init__(self, model_name="base"):
+        self.model = whisper.load_model(model_name)
+        self.temp_dir = None
+
+    def __enter__(self):
+        # Create secure temporary directory
+        self.temp_dir = tempfile.mkdtemp(prefix="secure_whisper_")
+        os.chmod(self.temp_dir, 0o700)  # Owner access only
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Secure cleanup
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            self.secure_delete_directory(self.temp_dir)
+
+    def secure_transcribe(self, audio_data, redact_pii=True):
+        """
+        Securely transcribe audio with PII redaction
+        """
+        try:
+            # Process in memory when possible
+            result = self.model.transcribe(audio_data, fp16=False)
+
+            if redact_pii:
+                result["text"] = self.redact_pii(result["text"])
+
+            return result
+
+        finally:
+            # Clear GPU memory
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+    def redact_pii(self, text):
+        """
+        Basic PII redaction (extend with more sophisticated methods)
+        """
+        import re
+
+        # Redact phone numbers
+        text = re.sub(r'\b\d{3}-\d{3}-\d{4}\b', '[PHONE]', text)
+        text = re.sub(r'\b\d{10}\b', '[PHONE]', text)
+
+        # Redact email addresses
+        text = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[EMAIL]', text)
+
+        # Redact SSNs
+        text = re.sub(r'\b\d{3}-\d{2}-\d{4}\b', '[SSN]', text)
+
+        return text
+
+    def secure_delete_directory(self, directory):
+        """
+        Securely delete directory and contents
+        """
+        for root, dirs, files in os.walk(directory, topdown=False):
+            for file in files:
+                file_path = os.path.join(root, file)
+                self.secure_delete_file(file_path)
+            for dir in dirs:
+                os.rmdir(os.path.join(root, dir))
+        os.rmdir(directory)
+
+    def secure_delete_file(self, file_path):
+        """
+        Overwrite file before deletion
+        """
+        if os.path.exists(file_path):
+            filesize = os.path.getsize(file_path)
+            with open(file_path, "r+b") as f:
+                f.seek(0)
+                f.write(os.urandom(filesize))  # Overwrite with random data
+                f.flush()
+                os.fsync(f.fileno())  # Force write to disk
+            os.remove(file_path)
+
+# Usage example
+def secure_transcribe_file(audio_file_path):
+    with SecureWhisperProcessor("base") as processor:
+        audio = whisper.load_audio(audio_file_path)
+        result = processor.secure_transcribe(audio, redact_pii=True)
+        return result["text"]
+```
+
+#### 2. Compliance Configuration
+```python
+# compliance_config.py
+HIPAA_CONFIG = {
+    'log_level': 'ERROR',  # Minimal logging
+    'temp_file_encryption': True,
+    'memory_cleanup': True,
+    'pii_redaction': True,
+    'audit_trail': True,
+    'data_retention_hours': 0,  # No data retention
+}
+
+GDPR_CONFIG = {
+    'consent_required': True,
+    'data_minimization': True,
+    'right_to_deletion': True,
+    'pseudonymization': True,
+    'encryption_at_rest': True,
+}
+
+def setup_compliance_environment(config_type="HIPAA"):
+    """
+    Configure environment for compliance requirements
+    """
+    if config_type == "HIPAA":
+        config = HIPAA_CONFIG
+    elif config_type == "GDPR":
+        config = GDPR_CONFIG
+    else:
+        raise ValueError("Unsupported compliance type")
+
+    # Configure logging
+    import logging
+    logging.getLogger().setLevel(getattr(logging, config.get('log_level', 'ERROR')))
+
+    # Set environment variables for secure processing
+    os.environ['WHISPER_DISABLE_CACHE'] = '1'
+    os.environ['WHISPER_TEMP_CLEANUP'] = '1'
+
+    return config
+```
+
+---
+
+## Summary and Recommendations
+
+### Priority Actions
+1. **Implement hallucination detection** for all transcription workflows
+2. **Standardize installation process** with environment validation
+3. **Add memory optimization** for production deployments
+4. **Enhance multilingual support** with language-specific processing
+5. **Implement security controls** for sensitive data handling
+
+### Best Practices
+- Always preprocess audio to remove silence
+- Use virtual environments for installation
+- Monitor memory usage during processing
+- Implement PII redaction for sensitive content
+- Test transcription quality with multiple temperature settings
+- Keep model weights and dependencies updated
+
+### Long-term Solutions
+- Contribute to community efforts for model improvement
+- Develop custom fine-tuned models for specific use cases
+- Implement comprehensive testing frameworks
+- Create standardized security protocols
+- Build monitoring and alerting systems for production use
+
+This analysis provides a roadmap for addressing the most critical Whisper issues while maintaining the tool's powerful capabilities for speech recognition tasks.

simple_test.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Simple test for enhanced hallucination detection without external dependencies."""
+
+import sys
+import os
+
+# Test import of the modules
+try:
+    sys.path.insert(0, '/Users/safayavatsal/github/OpenSource/whisper')
+
+    # Test basic imports
+    from whisper.enhancements.hallucination_detector import HallucinationDetector
+    from whisper.enhancements.confidence_scorer import ConfidenceScorer
+
+    print("✅ Successfully imported hallucination detection modules")
+
+    # Test basic functionality
+    detector = HallucinationDetector("en")
+    print("✅ Created HallucinationDetector instance")
+
+    # Test pattern detection
+    test_text = "Thanks for watching, please subscribe!"
+    result = detector.analyze_segment(test_text)
+    print(f"✅ Pattern detection test: '{test_text}'")
+    print(f"   - Detected hallucination: {result.is_hallucination}")
+    print(f"   - Confidence score: {result.confidence_score:.2f}")
+    print(f"   - Detected patterns: {result.detected_patterns}")
+
+    # Test with normal text
+    normal_text = "This is a normal conversation about the weather."
+    result2 = detector.analyze_segment(normal_text)
+    print(f"✅ Normal text test: '{normal_text}'")
+    print(f"   - Detected hallucination: {result2.is_hallucination}")
+    print(f"   - Confidence score: {result2.confidence_score:.2f}")
+
+    # Test confidence scorer
+    scorer = ConfidenceScorer("en")
+    print("✅ Created ConfidenceScorer instance")
+
+    print("\n🎉 Basic functionality test completed successfully!")
+    print("The enhanced hallucination detection system is working.")
+
+except ImportError as e:
+    print(f"❌ Import error: {e}")
+    sys.exit(1)
+except Exception as e:
+    print(f"❌ Unexpected error: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)

test_hallucination_detection.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+Test script for the enhanced hallucination detection system.
+This script tests the hallucination detection functionality with synthetic examples.
+"""
+
+import sys
+import os
+import numpy as np
+import torch
+
+# Add the whisper module to the path
+sys.path.insert(0, '/Users/safayavatsal/github/OpenSource/whisper')
+
+try:
+    from whisper.enhancements.hallucination_detector import (
+        HallucinationDetector,
+        detect_hallucinations,
+        filter_hallucinations
+    )
+    from whisper.enhancements.confidence_scorer import (
+        ConfidenceScorer,
+        calculate_confidence_score,
+        filter_by_confidence
+    )
+    print("✅ Enhanced hallucination detection modules imported successfully")
+except ImportError as e:
+    print(f"❌ Failed to import enhanced modules: {e}")
+    sys.exit(1)
+
+
+def test_pattern_detection():
+    """Test pattern-based hallucination detection."""
+    print("\n🔍 Testing pattern-based hallucination detection...")
+
+    # Test cases: (text, should_be_detected)
+    test_cases = [
+        ("Hello, how are you today?", False),
+        ("Thanks for watching, don't forget to subscribe!", True),
+        ("Please subscribe to my channel for more content.", True),
+        ("This is a normal conversation about the weather.", False),
+        ("Like and subscribe if you enjoyed this video.", True),
+        ("The meeting ended with everyone saying thank you.", False),
+        ("So so so this is repetitive text", True),
+        ("Regular speech without any issues here.", False),
+    ]
+
+    detector = HallucinationDetector("en")
+
+    for text, should_detect in test_cases:
+        result = detector.analyze_segment(text)
+        detected = result.is_hallucination
+        status = "✅" if detected == should_detect else "❌"
+        print(f"{status} '{text[:50]}...' -> Detected: {detected}, Score: {result.confidence_score:.2f}")
+        if result.detected_patterns:
+            print(f"   Patterns found: {result.detected_patterns}")
+
+
+def test_confidence_scoring():
+    """Test confidence scoring system."""
+    print("\n📊 Testing confidence scoring system...")
+
+    test_cases = [
+        {
+            'text': "Hello, this is a clear and well-articulated sentence.",
+            'avg_logprob': -0.2,
+            'compression_ratio': 1.5,
+            'no_speech_prob': 0.1
+        },
+        {
+            'text': "um uh er this is very uh unclear speech",
+            'avg_logprob': -1.5,
+            'compression_ratio': 2.8,
+            'no_speech_prob': 0.7
+        },
+        {
+            'text': "Short.",
+            'avg_logprob': -0.8,
+            'compression_ratio': 1.0,
+            'no_speech_prob': 0.3
+        },
+        {
+            'text': "This is a reasonably long sentence that contains meaningful content and should score well for confidence.",
+            'avg_logprob': -0.3,
+            'compression_ratio': 1.8,
+            'no_speech_prob': 0.2
+        }
+    ]
+
+    scorer = ConfidenceScorer("en")
+
+    for i, case in enumerate(test_cases):
+        result = scorer.score_segment_confidence(**case)
+        print(f"Test {i+1}: Overall Score: {result.overall_score:.2f}")
+        print(f"  Text: '{case['text'][:50]}...'")
+        print(f"  Component scores: {result.component_scores}")
+        print()
+
+
+def test_segment_filtering():
+    """Test segment filtering functionality."""
+    print("\n🔧 Testing segment filtering...")
+
+    # Create mock segments with different quality levels
+    test_segments = [
+        {
+            'text': 'This is good quality speech.',
+            'avg_logprob': -0.2,
+            'compression_ratio': 1.5,
+            'no_speech_prob': 0.1,
+            'start': 0.0,
+            'end': 2.0
+        },
+        {
+            'text': 'Thanks for watching and please subscribe!',
+            'avg_logprob': -0.4,
+            'compression_ratio': 2.1,
+            'no_speech_prob': 0.3,
+            'start': 2.0,
+            'end': 4.0
+        },
+        {
+            'text': 'Another normal sentence here.',
+            'avg_logprob': -0.3,
+            'compression_ratio': 1.7,
+            'no_speech_prob': 0.2,
+            'start': 4.0,
+            'end': 6.0
+        },
+        {
+            'text': 'Like and subscribe to my channel for more content!',
+            'avg_logprob': -0.8,
+            'compression_ratio': 2.5,
+            'no_speech_prob': 0.5,
+            'start': 6.0,
+            'end': 8.0
+        }
+    ]
+
+    print(f"Original segments: {len(test_segments)}")
+
+    # Test hallucination filtering
+    filtered_segments = filter_hallucinations(test_segments, language="en", strict_mode=False)
+    print(f"After hallucination filtering: {len(filtered_segments)}")
+    for segment in filtered_segments:
+        if 'hallucination_analysis' in segment:
+            print(f"  - '{segment['text'][:30]}...' (confidence: {segment['hallucination_analysis']['confidence_score']:.2f})")
+
+    # Test confidence filtering
+    confidence_filtered = filter_by_confidence(test_segments, min_confidence=0.5, language="en")
+    print(f"After confidence filtering (>0.5): {len(confidence_filtered)}")
+    for segment in confidence_filtered:
+        if 'confidence_analysis' in segment:
+            print(f"  - '{segment['text'][:30]}...' (score: {segment['confidence_analysis']['overall_score']:.2f})")
+
+
+def test_multilingual_support():
+    """Test multilingual hallucination detection."""
+    print("\n🌐 Testing multilingual support...")
+
+    test_cases = [
+        ("Gracias por ver este video", "es", True),
+        ("Hola, ¿cómo estás hoy?", "es", False),
+        ("Merci de regarder cette vidéo", "fr", True),
+        ("Bonjour, comment allez-vous?", "fr", False),
+    ]
+
+    for text, language, should_detect in test_cases:
+        detector = HallucinationDetector(language)
+        result = detector.analyze_segment(text)
+        status = "✅" if result.is_hallucination == should_detect else "❌"
+        print(f"{status} [{language}] '{text}' -> Detected: {result.is_hallucination}")
+
+
+def main():
+    """Run all tests."""
+    print("🚀 Testing Enhanced Hallucination Detection System")
+    print("=" * 60)
+
+    try:
+        test_pattern_detection()
+        test_confidence_scoring()
+        test_segment_filtering()
+        test_multilingual_support()
+
+        print("\n🎉 All tests completed successfully!")
+        print("\nThe enhanced hallucination detection system is working properly.")
+        print("Key features tested:")
+        print("  ✅ Pattern-based detection (YouTube artifacts, repetitions)")
+        print("  ✅ Confidence scoring (multiple factors)")
+        print("  ✅ Segment filtering (hallucinations and confidence)")
+        print("  ✅ Multilingual support (Spanish, French)")
+
+    except Exception as e:
+        print(f"\n❌ Test failed with error: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

whisper/enhancements/__init__.py

@@ -0,0 +1,15 @@
+# Whisper Enhancements Module
+"""
+This module contains enhanced functionality for the OpenAI Whisper speech recognition system.
+These enhancements provide additional features while maintaining backward compatibility with the core Whisper API.
+"""
+
+from .hallucination_detector import HallucinationDetector, detect_hallucinations
+from .confidence_scorer import ConfidenceScorer, calculate_confidence_score
+
+__all__ = [
+    'HallucinationDetector',
+    'detect_hallucinations',
+    'ConfidenceScorer',
+    'calculate_confidence_score'
+]

whisper/enhancements/confidence_scorer.py

@@ -0,0 +1,402 @@
+"""
+Confidence Scoring System for Whisper Transcriptions
+
+This module provides enhanced confidence scoring beyond the basic metrics
+provided by Whisper, incorporating multiple factors for more accurate
+assessment of transcription quality.
+"""
+
+import numpy as np
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass
+
+
+@dataclass
+class ConfidenceMetrics:
+    """Container for confidence scoring metrics."""
+    overall_score: float
+    component_scores: Dict[str, float]
+    quality_indicators: Dict[str, float]
+    recommended_threshold: float
+
+
+class ConfidenceScorer:
+    """
+    Advanced confidence scoring system for Whisper transcriptions.
+
+    Combines multiple factors to provide more accurate confidence assessment:
+    - Whisper's internal metrics (log probabilities, compression ratios)
+    - Temporal consistency (timing patterns, speech rate)
+    - Linguistic coherence (grammar, vocabulary consistency)
+    - Audio quality indicators (signal-to-noise estimations)
+    """
+
+    def __init__(self, language: str = "en"):
+        """
+        Initialize the confidence scorer.
+
+        Args:
+            language: Target language for language-specific scoring
+        """
+        self.language = language
+
+    def score_segment_confidence(
+        self,
+        text: str,
+        avg_logprob: Optional[float] = None,
+        compression_ratio: Optional[float] = None,
+        no_speech_prob: Optional[float] = None,
+        word_timestamps: Optional[List[dict]] = None,
+        segment_duration: Optional[float] = None
+    ) -> ConfidenceMetrics:
+        """
+        Calculate comprehensive confidence score for a transcription segment.
+
+        Args:
+            text: Transcribed text
+            avg_logprob: Average log probability from Whisper
+            compression_ratio: Compression ratio from Whisper
+            no_speech_prob: No-speech probability from Whisper
+            word_timestamps: Word-level timestamps if available
+            segment_duration: Duration of the audio segment
+
+        Returns:
+            ConfidenceMetrics with detailed scoring
+        """
+        component_scores = {}
+        quality_indicators = {}
+
+        # 1. Whisper Internal Metrics Score
+        whisper_score = self._score_whisper_metrics(
+            avg_logprob, compression_ratio, no_speech_prob
+        )
+        component_scores['whisper_metrics'] = whisper_score
+
+        # 2. Text Quality Score
+        text_score = self._score_text_quality(text)
+        component_scores['text_quality'] = text_score
+
+        # 3. Temporal Consistency Score
+        temporal_score = self._score_temporal_consistency(
+            word_timestamps, segment_duration, len(text.split()) if text else 0
+        )
+        component_scores['temporal_consistency'] = temporal_score
+
+        # 4. Linguistic Coherence Score
+        linguistic_score = self._score_linguistic_coherence(text)
+        component_scores['linguistic_coherence'] = linguistic_score
+
+        # Calculate overall score with weighted combination
+        overall_score = (
+            whisper_score * 0.4 +        # Whisper's own confidence is most important
+            text_score * 0.25 +          # Text quality indicators
+            temporal_score * 0.2 +       # Timing consistency
+            linguistic_score * 0.15      # Language model coherence
+        )
+
+        # Quality indicators for analysis
+        quality_indicators.update({
+            'text_length': len(text) if text else 0,
+            'word_count': len(text.split()) if text else 0,
+            'avg_word_length': np.mean([len(word) for word in text.split()]) if text else 0,
+            'speech_rate': self._calculate_speech_rate(text, segment_duration),
+            'repetition_rate': self._calculate_repetition_rate(text)
+        })
+
+        # Determine recommended threshold based on use case
+        recommended_threshold = self._determine_threshold(overall_score, component_scores)
+
+        return ConfidenceMetrics(
+            overall_score=overall_score,
+            component_scores=component_scores,
+            quality_indicators=quality_indicators,
+            recommended_threshold=recommended_threshold
+        )
+
+    def _score_whisper_metrics(
+        self,
+        avg_logprob: Optional[float],
+        compression_ratio: Optional[float],
+        no_speech_prob: Optional[float]
+    ) -> float:
+        """Score based on Whisper's internal metrics."""
+        score = 0.7  # Default neutral score
+
+        # Log probability scoring (higher is better, but values are negative)
+        if avg_logprob is not None:
+            if avg_logprob > -0.3:
+                score += 0.3  # Very confident
+            elif avg_logprob > -0.6:
+                score += 0.2  # Confident
+            elif avg_logprob > -1.0:
+                score += 0.1  # Somewhat confident
+            elif avg_logprob < -1.5:
+                score -= 0.2  # Low confidence
+            elif avg_logprob < -2.0:
+                score -= 0.4  # Very low confidence
+
+        # Compression ratio scoring (lower is better)
+        if compression_ratio is not None:
+            if compression_ratio < 1.5:
+                score += 0.2  # Good compression
+            elif compression_ratio < 2.0:
+                score += 0.1  # Acceptable compression
+            elif compression_ratio > 2.4:
+                score -= 0.3  # High compression (likely repetitive)
+            elif compression_ratio > 3.0:
+                score -= 0.5  # Very high compression
+
+        # No speech probability (lower is better for transcription)
+        if no_speech_prob is not None:
+            if no_speech_prob < 0.2:
+                score += 0.1  # Confident there is speech
+            elif no_speech_prob > 0.6:
+                score -= 0.2  # Likely no speech
+            elif no_speech_prob > 0.8:
+                score -= 0.4  # Very likely no speech
+
+        return max(0.0, min(1.0, score))
+
+    def _score_text_quality(self, text: str) -> float:
+        """Score based on text characteristics."""
+        if not text or not text.strip():
+            return 0.0
+
+        text = text.strip()
+        score = 0.5
+
+        # Length-based scoring
+        length = len(text)
+        if 20 <= length <= 200:
+            score += 0.2  # Good length
+        elif 10 <= length < 20 or 200 < length <= 500:
+            score += 0.1  # Acceptable length
+        elif length < 10:
+            score -= 0.2  # Too short
+        elif length > 500:
+            score -= 0.1  # Quite long
+
+        # Character diversity
+        unique_chars = len(set(text.lower()))
+        total_chars = len(text.replace(' ', ''))
+        if total_chars > 0:
+            diversity = unique_chars / total_chars
+            if diversity > 0.3:
+                score += 0.1
+            elif diversity < 0.15:
+                score -= 0.1
+
+        # Punctuation presence (indicates structure)
+        punctuation_count = sum(1 for char in text if char in '.,!?;:')
+        word_count = len(text.split())
+        if word_count > 0:
+            punct_ratio = punctuation_count / word_count
+            if 0.05 <= punct_ratio <= 0.3:  # Reasonable punctuation
+                score += 0.1
+
+        # Check for excessive capitalization
+        if text.isupper() and len(text) > 10:
+            score -= 0.15  # All caps is often transcription error
+
+        return max(0.0, min(1.0, score))
+
+    def _score_temporal_consistency(
+        self,
+        word_timestamps: Optional[List[dict]],
+        segment_duration: Optional[float],
+        word_count: int
+    ) -> float:
+        """Score based on temporal patterns in word timestamps."""
+        if not word_timestamps or segment_duration is None or word_count == 0:
+            return 0.5  # Neutral score when timing data unavailable
+
+        score = 0.5
+
+        try:
+            # Calculate word durations
+            word_durations = []
+            for word_info in word_timestamps:
+                if 'start' in word_info and 'end' in word_info:
+                    duration = word_info['end'] - word_info['start']
+                    word_durations.append(duration)
+
+            if not word_durations:
+                return 0.5
+
+            # Analyze timing consistency
+            avg_word_duration = np.mean(word_durations)
+            word_duration_std = np.std(word_durations)
+
+            # Reasonable word duration (0.1 to 1.0 seconds typically)
+            if 0.1 <= avg_word_duration <= 1.0:
+                score += 0.2
+            elif avg_word_duration < 0.05 or avg_word_duration > 2.0:
+                score -= 0.2
+
+            # Consistency in word durations (lower std is better)
+            if word_duration_std < avg_word_duration * 0.5:
+                score += 0.15  # Consistent timing
+            elif word_duration_std > avg_word_duration * 2.0:
+                score -= 0.15  # Very inconsistent timing
+
+            # Speech rate analysis
+            estimated_speech_rate = word_count / segment_duration * 60  # words per minute
+            if 120 <= estimated_speech_rate <= 200:
+                score += 0.15  # Normal speech rate
+            elif 80 <= estimated_speech_rate < 120 or 200 < estimated_speech_rate <= 300:
+                score += 0.05  # Slightly unusual but acceptable
+            elif estimated_speech_rate < 60 or estimated_speech_rate > 400:
+                score -= 0.2   # Very unusual speech rate
+
+        except (KeyError, TypeError, ValueError):
+            # If there are issues with timestamp data, return neutral score
+            return 0.5
+
+        return max(0.0, min(1.0, score))
+
+    def _score_linguistic_coherence(self, text: str) -> float:
+        """Score based on linguistic patterns and coherence."""
+        if not text or not text.strip():
+            return 0.0
+
+        text = text.strip()
+        words = text.split()
+        score = 0.5
+
+        if len(words) == 0:
+            return 0.0
+
+        # Check for reasonable sentence structure
+        sentences = [s.strip() for s in text.replace('!', '.').replace('?', '.').split('.') if s.strip()]
+        if sentences:
+            avg_sentence_length = np.mean([len(s.split()) for s in sentences])
+            if 5 <= avg_sentence_length <= 20:
+                score += 0.2
+            elif 3 <= avg_sentence_length < 5 or 20 < avg_sentence_length <= 30:
+                score += 0.1
+            elif avg_sentence_length < 3 or avg_sentence_length > 30:
+                score -= 0.1
+
+        # Check for excessive repetition
+        repetition_penalty = self._calculate_repetition_rate(text)
+        score -= repetition_penalty * 0.3
+
+        # Vocabulary diversity
+        unique_words = len(set(word.lower() for word in words))
+        vocabulary_diversity = unique_words / len(words) if words else 0
+        if vocabulary_diversity > 0.7:
+            score += 0.15
+        elif vocabulary_diversity < 0.3:
+            score -= 0.15
+
+        # Check for common filler words (moderate amount is normal)
+        filler_words = {'um', 'uh', 'er', 'ah', 'like', 'you know', 'so', 'well'}
+        filler_count = sum(1 for word in words if word.lower() in filler_words)
+        filler_ratio = filler_count / len(words) if words else 0
+        if filler_ratio > 0.15:  # Too many fillers
+            score -= 0.1
+        elif filler_ratio > 0.3:   # Excessive fillers
+            score -= 0.2
+
+        return max(0.0, min(1.0, score))
+
+    def _calculate_speech_rate(self, text: str, duration: Optional[float]) -> float:
+        """Calculate estimated speech rate in words per minute."""
+        if not text or not duration or duration <= 0:
+            return 0.0
+
+        word_count = len(text.split())
+        return word_count / duration * 60
+
+    def _calculate_repetition_rate(self, text: str) -> float:
+        """Calculate the rate of word repetitions in text."""
+        if not text:
+            return 0.0
+
+        words = text.lower().split()
+        if len(words) < 2:
+            return 0.0
+
+        repetitions = 0
+        for i in range(len(words) - 1):
+            if words[i] == words[i + 1]:
+                repetitions += 1
+
+        return repetitions / len(words)
+
+    def _determine_threshold(self, overall_score: float, component_scores: Dict[str, float]) -> float:
+        """Determine recommended confidence threshold based on score characteristics."""
+        # Base threshold
+        if overall_score > 0.8:
+            return 0.7    # High quality, can be more permissive
+        elif overall_score > 0.6:
+            return 0.5    # Medium quality, standard threshold
+        else:
+            return 0.3    # Lower quality, need lower threshold to get any results
+
+
+def calculate_confidence_score(
+    text: str,
+    language: str = "en",
+    **whisper_metrics
+) -> ConfidenceMetrics:
+    """
+    Convenience function for quick confidence scoring.
+
+    Args:
+        text: Transcribed text to score
+        language: Language code
+        **whisper_metrics: Metrics from Whisper (avg_logprob, etc.)
+
+    Returns:
+        ConfidenceMetrics with scoring details
+    """
+    scorer = ConfidenceScorer(language)
+    return scorer.score_segment_confidence(text, **whisper_metrics)
+
+
+def filter_by_confidence(
+    segments: List[dict],
+    min_confidence: float = 0.5,
+    language: str = "en"
+) -> List[dict]:
+    """
+    Filter segments based on confidence scores.
+
+    Args:
+        segments: List of segment dictionaries from Whisper
+        min_confidence: Minimum confidence threshold
+        language: Language code
+
+    Returns:
+        Filtered list of high-confidence segments
+    """
+    scorer = ConfidenceScorer(language)
+    filtered_segments = []
+
+    for segment in segments:
+        text = segment.get('text', '')
+
+        # Extract metrics if available
+        kwargs = {}
+        for key in ['avg_logprob', 'compression_ratio', 'no_speech_prob']:
+            if key in segment:
+                kwargs[key] = segment[key]
+
+        if 'words' in segment:
+            kwargs['word_timestamps'] = segment['words']
+        if 'start' in segment and 'end' in segment:
+            kwargs['segment_duration'] = segment['end'] - segment['start']
+
+        confidence_result = scorer.score_segment_confidence(text, **kwargs)
+
+        if confidence_result.overall_score >= min_confidence:
+            # Add confidence metadata
+            segment['confidence_analysis'] = {
+                'overall_score': confidence_result.overall_score,
+                'component_scores': confidence_result.component_scores,
+                'quality_indicators': confidence_result.quality_indicators
+            }
+            filtered_segments.append(segment)
+
+    return filtered_segments

whisper/enhancements/hallucination_detector.py

@@ -0,0 +1,393 @@
+"""
+Advanced Hallucination Detection for OpenAI Whisper
+
+This module implements sophisticated hallucination detection and mitigation techniques
+based on research findings and community-reported patterns.
+"""
+
+import re
+from typing import Dict, List, Optional, Tuple, Union
+import numpy as np
+import torch
+from dataclasses import dataclass
+
+
+@dataclass
+class HallucinationResult:
+    """Result of hallucination detection analysis."""
+    is_hallucination: bool
+    confidence_score: float
+    detected_patterns: List[str]
+    risk_factors: Dict[str, float]
+    recommended_action: str
+
+
+class HallucinationDetector:
+    """
+    Advanced hallucination detection system for Whisper transcriptions.
+
+    Based on research showing that hallucinations occur in ~80% of transcriptions
+    in certain conditions, this detector uses multiple detection strategies:
+
+    1. Pattern-based detection (YouTube artifacts, common phrases)
+    2. Repetition analysis (looping behavior detection)
+    3. Statistical analysis (compression ratios, log probabilities)
+    4. Temporal analysis (silence periods, timing consistency)
+    """
+
+    def __init__(self, language: str = "en"):
+        """
+        Initialize the hallucination detector.
+
+        Args:
+            language: Target language code for language-specific patterns
+        """
+        self.language = language
+        self.patterns = self._load_hallucination_patterns()
+        self.repetition_threshold = 3  # Number of repetitions to flag
+        self.silence_threshold = 2.0   # Seconds of silence before text
+
+    def _load_hallucination_patterns(self) -> Dict[str, List[str]]:
+        """Load language-specific hallucination patterns."""
+        patterns = {
+            "en": [
+                # YouTube artifacts (most common)
+                "thank you for watching",
+                "thanks for watching",
+                "please subscribe",
+                "like and subscribe",
+                "don't forget to subscribe",
+                "hit the bell icon",
+                "ring that notification bell",
+                "check out my other videos",
+                "leave a comment below",
+                "see you in the next video",
+                "until next time",
+
+                # Generic endings
+                "that's all for now",
+                "that's it for today",
+                "catch you later",
+                "peace out",
+                "see you soon",
+
+                # Advertisement artifacts
+                "this video is sponsored by",
+                "thanks to our sponsor",
+                "use code",
+                "get % off",
+                "limited time offer",
+                "act now",
+                "call now",
+
+                # Repetitive/looping indicators
+                "and then and then",
+                "so so so",
+                "the the the",
+                "i mean i mean",
+                "you know you know",
+
+                # Non-speech sounds interpreted as speech
+                "hmm hmm hmm",
+                "uh uh uh",
+                "ah ah ah",
+                "mm mm mm",
+            ],
+            "es": [
+                "gracias por ver",
+                "suscríbete",
+                "dale like",
+                "no olvides suscribirte",
+                "hasta la próxima",
+                "nos vemos",
+            ],
+            "fr": [
+                "merci de regarder",
+                "abonnez-vous",
+                "n'oubliez pas de vous abonner",
+                "à bientôt",
+                "merci d'avoir regardé",
+            ]
+        }
+        return patterns.get(self.language, patterns["en"])
+
+    def detect_pattern_hallucinations(self, text: str) -> Tuple[bool, List[str], float]:
+        """
+        Detect hallucinations based on known patterns.
+
+        Args:
+            text: Transcribed text to analyze
+
+        Returns:
+            Tuple of (is_hallucination, detected_patterns, confidence_score)
+        """
+        text_lower = text.lower().strip()
+        detected_patterns = []
+        penalty_score = 0.0
+
+        for pattern in self.patterns:
+            if pattern in text_lower:
+                detected_patterns.append(pattern)
+                # Weight penalties by pattern severity
+                if any(keyword in pattern for keyword in ["subscribe", "like", "sponsor"]):
+                    penalty_score += 0.4  # High penalty for YouTube artifacts
+                elif any(keyword in pattern for keyword in ["thank", "watch", "video"]):
+                    penalty_score += 0.3  # Medium penalty for video endings
+                else:
+                    penalty_score += 0.2  # Lower penalty for other patterns
+
+        is_hallucination = penalty_score > 0.3 or len(detected_patterns) > 1
+        confidence_score = max(0.0, 1.0 - penalty_score)
+
+        return is_hallucination, detected_patterns, confidence_score
+
+    def detect_repetition_hallucinations(self, text: str) -> Tuple[bool, float]:
+        """
+        Detect hallucinations based on repetitive patterns.
+
+        Args:
+            text: Transcribed text to analyze
+
+        Returns:
+            Tuple of (is_hallucination, confidence_score)
+        """
+        words = text.lower().split()
+        if len(words) < 4:
+            return False, 1.0
+
+        # Check for immediate repetitions
+        repetition_count = 0
+        for i in range(len(words) - 1):
+            if words[i] == words[i + 1]:
+                repetition_count += 1
+
+        repetition_ratio = repetition_count / len(words)
+
+        # Check for phrase repetitions
+        phrase_repetitions = 0
+        for i in range(len(words) - 5):
+            phrase = " ".join(words[i:i+3])
+            remaining_text = " ".join(words[i+3:])
+            if phrase in remaining_text:
+                phrase_repetitions += 1
+
+        phrase_ratio = phrase_repetitions / max(1, len(words) - 5)
+
+        # Combine metrics
+        total_repetition_score = repetition_ratio + (phrase_ratio * 2)
+        is_hallucination = total_repetition_score > 0.3
+        confidence_score = max(0.0, 1.0 - total_repetition_score * 2)
+
+        return is_hallucination, confidence_score
+
+    def detect_statistical_hallucinations(
+        self,
+        text: str,
+        avg_logprob: Optional[float] = None,
+        compression_ratio: Optional[float] = None,
+        no_speech_prob: Optional[float] = None
+    ) -> Tuple[bool, float]:
+        """
+        Detect hallucinations using statistical metrics from Whisper.
+
+        Args:
+            text: Transcribed text
+            avg_logprob: Average log probability of tokens
+            compression_ratio: Compression ratio from Whisper
+            no_speech_prob: No-speech probability from Whisper
+
+        Returns:
+            Tuple of (is_hallucination, confidence_score)
+        """
+        risk_score = 0.0
+
+        # Text length analysis
+        if len(text.strip()) < 10:
+            risk_score += 0.2  # Very short text is suspicious
+        elif len(text.strip()) > 500:
+            risk_score += 0.1  # Very long text without breaks
+
+        # Log probability analysis
+        if avg_logprob is not None:
+            if avg_logprob < -1.0:
+                risk_score += 0.3  # Low confidence from model
+            elif avg_logprob < -0.5:
+                risk_score += 0.1
+
+        # Compression ratio analysis
+        if compression_ratio is not None:
+            if compression_ratio > 2.4:
+                risk_score += 0.4  # High compression ratio indicates repetitive text
+            elif compression_ratio > 2.0:
+                risk_score += 0.2
+
+        # No-speech probability analysis
+        if no_speech_prob is not None:
+            if no_speech_prob > 0.6:
+                risk_score += 0.3  # High probability of no speech
+            elif no_speech_prob > 0.4:
+                risk_score += 0.1
+
+        is_hallucination = risk_score > 0.4
+        confidence_score = max(0.0, 1.0 - risk_score)
+
+        return is_hallucination, confidence_score
+
+    def analyze_segment(
+        self,
+        text: str,
+        start_time: Optional[float] = None,
+        end_time: Optional[float] = None,
+        avg_logprob: Optional[float] = None,
+        compression_ratio: Optional[float] = None,
+        no_speech_prob: Optional[float] = None,
+        preceding_silence: Optional[float] = None
+    ) -> HallucinationResult:
+        """
+        Comprehensive hallucination analysis for a text segment.
+
+        Args:
+            text: Transcribed text segment
+            start_time: Segment start time in seconds
+            end_time: Segment end time in seconds
+            avg_logprob: Average log probability
+            compression_ratio: Text compression ratio
+            no_speech_prob: No-speech probability
+            preceding_silence: Duration of silence before this segment
+
+        Returns:
+            HallucinationResult with analysis details
+        """
+        # Pattern-based detection
+        pattern_halluc, detected_patterns, pattern_confidence = self.detect_pattern_hallucinations(text)
+
+        # Repetition-based detection
+        repetition_halluc, repetition_confidence = self.detect_repetition_hallucinations(text)
+
+        # Statistical detection
+        statistical_halluc, statistical_confidence = self.detect_statistical_hallucinations(
+            text, avg_logprob, compression_ratio, no_speech_prob
+        )
+
+        # Temporal analysis (silence-based detection)
+        silence_risk = 0.0
+        if preceding_silence is not None and preceding_silence > self.silence_threshold:
+            silence_risk = min(0.4, preceding_silence / 10.0)  # More silence = higher risk
+
+        # Combine all detection methods
+        risk_factors = {
+            "pattern_risk": 1.0 - pattern_confidence,
+            "repetition_risk": 1.0 - repetition_confidence,
+            "statistical_risk": 1.0 - statistical_confidence,
+            "silence_risk": silence_risk
+        }
+
+        # Weighted combination (patterns are strongest indicator)
+        combined_confidence = (
+            pattern_confidence * 0.4 +
+            repetition_confidence * 0.3 +
+            statistical_confidence * 0.2 +
+            (1.0 - silence_risk) * 0.1
+        )
+
+        is_hallucination = (
+            pattern_halluc or
+            repetition_halluc or
+            statistical_halluc or
+            silence_risk > 0.3
+        )
+
+        # Determine recommended action
+        if is_hallucination:
+            if combined_confidence < 0.3:
+                recommended_action = "reject_segment"
+            elif combined_confidence < 0.6:
+                recommended_action = "flag_for_review"
+            else:
+                recommended_action = "accept_with_warning"
+        else:
+            recommended_action = "accept"
+
+        return HallucinationResult(
+            is_hallucination=is_hallucination,
+            confidence_score=combined_confidence,
+            detected_patterns=detected_patterns,
+            risk_factors=risk_factors,
+            recommended_action=recommended_action
+        )
+
+
+def detect_hallucinations(
+    text: str,
+    language: str = "en",
+    **whisper_metrics
+) -> HallucinationResult:
+    """
+    Convenience function for quick hallucination detection.
+
+    Args:
+        text: Text to analyze
+        language: Language code
+        **whisper_metrics: Additional metrics from Whisper (avg_logprob, etc.)
+
+    Returns:
+        HallucinationResult
+    """
+    detector = HallucinationDetector(language)
+    return detector.analyze_segment(text, **whisper_metrics)
+
+
+def filter_hallucinations(
+    segments: List[dict],
+    language: str = "en",
+    strict_mode: bool = False
+) -> List[dict]:
+    """
+    Filter out likely hallucinated segments from transcription results.
+
+    Args:
+        segments: List of segment dictionaries from Whisper
+        language: Language code
+        strict_mode: If True, use stricter filtering criteria
+
+    Returns:
+        Filtered list of segments
+    """
+    detector = HallucinationDetector(language)
+    filtered_segments = []
+
+    for segment in segments:
+        text = segment.get('text', '')
+
+        # Extract metrics if available
+        kwargs = {}
+        if 'avg_logprob' in segment:
+            kwargs['avg_logprob'] = segment['avg_logprob']
+        if 'compression_ratio' in segment:
+            kwargs['compression_ratio'] = segment['compression_ratio']
+        if 'no_speech_prob' in segment:
+            kwargs['no_speech_prob'] = segment['no_speech_prob']
+        if 'start' in segment:
+            kwargs['start_time'] = segment['start']
+        if 'end' in segment:
+            kwargs['end_time'] = segment['end']
+
+        result = detector.analyze_segment(text, **kwargs)
+
+        # Apply filtering based on mode
+        if strict_mode:
+            # In strict mode, only accept high-confidence segments
+            if result.recommended_action == "accept" and result.confidence_score > 0.7:
+                filtered_segments.append(segment)
+        else:
+            # In normal mode, reject only obvious hallucinations
+            if result.recommended_action != "reject_segment":
+                # Add confidence metadata
+                segment['hallucination_analysis'] = {
+                    'confidence_score': result.confidence_score,
+                    'risk_factors': result.risk_factors,
+                    'detected_patterns': result.detected_patterns
+                }
+                filtered_segments.append(segment)
+
+    return filtered_segments

whisper/transcribe.py

@@ -31,6 +31,14 @@ from .utils import (
     str2bool,
 )
 
+# Enhanced hallucination detection
+try:
+    from .enhancements.hallucination_detector import HallucinationDetector, filter_hallucinations
+    from .enhancements.confidence_scorer import ConfidenceScorer, filter_by_confidence
+    ENHANCED_DETECTION_AVAILABLE = True
+except ImportError:
+    ENHANCED_DETECTION_AVAILABLE = False
+
 if TYPE_CHECKING:
     from .model import Whisper
 
@@ -52,6 +60,11 @@ def transcribe(
     append_punctuations: str = "\"'.。,，!！?？:：”)]}、",
     clip_timestamps: Union[str, List[float]] = "0",
     hallucination_silence_threshold: Optional[float] = None,
+    # Enhanced hallucination detection parameters
+    enhanced_hallucination_detection: bool = False,
+    hallucination_detection_language: Optional[str] = None,
+    strict_hallucination_filtering: bool = False,
+    confidence_threshold: Optional[float] = None,
     **decode_options,
 ):
     """
@@ -119,6 +132,22 @@ def transcribe(
         When word_timestamps is True, skip silent periods longer than this threshold (in seconds)
         when a possible hallucination is detected
 
+    enhanced_hallucination_detection: bool
+        Enable advanced hallucination detection using pattern recognition, repetition analysis,
+        and statistical methods. Requires the enhancements module.
+
+    hallucination_detection_language: Optional[str]
+        Language code for language-specific hallucination patterns. If None, uses the detected
+        or specified transcription language.
+
+    strict_hallucination_filtering: bool
+        Apply strict filtering to reject segments with any hallucination indicators.
+        When False, only obvious hallucinations are filtered.
+
+    confidence_threshold: Optional[float]
+        Minimum confidence score (0.0-1.0) for accepting transcribed segments.
+        If None, uses adaptive thresholding based on overall quality.
+
     Returns
     -------
     A dictionary containing the resulting text ("text") and segment-level details ("segments"), and
@@ -507,9 +536,60 @@ def transcribe(
             # update progress bar
             pbar.update(min(content_frames, seek) - previous_seek)
 
+    # Apply enhanced hallucination detection if enabled
+    final_segments = all_segments
+    final_text = tokenizer.decode(all_tokens[len(initial_prompt_tokens) :])
+
+    if enhanced_hallucination_detection and ENHANCED_DETECTION_AVAILABLE:
+        detection_language = hallucination_detection_language or language or "en"
+
+        # Apply hallucination filtering
+        if final_segments:
+            filtered_segments = filter_hallucinations(
+                final_segments,
+                language=detection_language,
+                strict_mode=strict_hallucination_filtering
+            )
+
+            # Apply confidence-based filtering if threshold is provided
+            if confidence_threshold is not None:
+                filtered_segments = filter_by_confidence(
+                    filtered_segments,
+                    min_confidence=confidence_threshold,
+                    language=detection_language
+                )
+
+            # Update segments and regenerate text from filtered segments
+            final_segments = filtered_segments
+            if filtered_segments:
+                # Reconstruct text from filtered segments
+                filtered_tokens = []
+                for segment in filtered_segments:
+                    if "tokens" in segment and segment["tokens"]:
+                        filtered_tokens.extend(segment["tokens"])
+                    else:
+                        # Fallback: tokenize the segment text
+                        segment_tokens = tokenizer.encode(segment.get("text", ""))
+                        filtered_tokens.extend(segment_tokens)
+
+                if filtered_tokens:
+                    final_text = tokenizer.decode(filtered_tokens)
+                else:
+                    final_text = ""  # All segments were filtered out
+            else:
+                final_text = ""  # No segments passed filtering
+
+    elif enhanced_hallucination_detection and not ENHANCED_DETECTION_AVAILABLE:
+        import warnings
+        warnings.warn(
+            "Enhanced hallucination detection was requested but the enhancements module is not available. "
+            "Falling back to standard Whisper behavior.",
+            RuntimeWarning
+        )
+
     return dict(
-        text=tokenizer.decode(all_tokens[len(initial_prompt_tokens) :]),
-        segments=all_segments,
+        text=final_text,
+        segments=final_segments,
         language=language,
     )
 
@@ -564,6 +644,12 @@ def cli():
     parser.add_argument("--threads", type=optional_int, default=0, help="number of threads used by torch for CPU inference; supercedes MKL_NUM_THREADS/OMP_NUM_THREADS")
     parser.add_argument("--clip_timestamps", type=str, default="0", help="comma-separated list start,end,start,end,... timestamps (in seconds) of clips to process, where the last end timestamp defaults to the end of the file")
     parser.add_argument("--hallucination_silence_threshold", type=optional_float, help="(requires --word_timestamps True) skip silent periods longer than this threshold (in seconds) when a possible hallucination is detected")
+
+    # Enhanced hallucination detection arguments
+    parser.add_argument("--enhanced_hallucination_detection", type=str2bool, default=False, help="enable advanced hallucination detection using pattern recognition and statistical analysis")
+    parser.add_argument("--hallucination_detection_language", type=str, default=None, help="language code for hallucination pattern detection (defaults to transcription language)")
+    parser.add_argument("--strict_hallucination_filtering", type=str2bool, default=False, help="apply strict filtering to reject any segments with hallucination indicators")
+    parser.add_argument("--confidence_threshold", type=optional_float, default=None, help="minimum confidence score (0.0-1.0) for accepting transcribed segments")
     # fmt: on
 
     args = parser.parse_args().__dict__