Поймать голосового робота: детекция автоответчиков с T-One и Whisper

Почему простые правила уже не работают

Раньше определить автоответчика было просто: неестественные паузы, механический голос, повторяющиеся фразы. В 2026 году это не сработает. Современные TTS-системы генерируют речь с интонациями, эмоциями и даже дыханием. Они вставляют случайные междометия, делают микропаузы и меняют темп.

Проблема в том, что ложные срабатывания дороже пропущенных роботов. Когда система ошибочно помечает живого оператора как автоответчика, вы теряете клиента. Когда пропускает робота - тратите ресурсы колл-центра на бессмысленный диалог.

T-One против Whisper: зачем нужны две модели

Первая мысль: взять Whisper v3 Large (последняя стабильная версия на февраль 2026) и анализировать текст. Не работает. Точнее, работает плохо. Современные автоответчики генерируют грамматически правильную речь с контекстными ответами.

T-One - специализированная модель для детекции синтезированной речи, выпущенная в конце 2025 года. Она анализирует не текст, а акустические артефакты: микроколебания частоты, неестественные гармоники, артефакты кодека.

Архитектура системы: от аудио до скоринга

1 Подготовка аудиопотока

Телефонный звонок приходит в формате μ-law 8 кГц. Первый шаг - нормализация до 16 кГц PCM. Не используйте автоматическую нормализацию громкости - она сглаживает артефакты, которые ищет T-One.

import librosa
import soundfile as sf

def prepare_audio(input_path, output_path):
    # Загружаем с исходной частотой
    audio, sr = librosa.load(input_path, sr=None)
    
    # Ресемплируем только если нужно
    if sr != 16000:
        audio = librosa.resample(audio, orig_sr=sr, target_sr=16000)
    
    # Сохраняем без нормализации амплитуды
    sf.write(output_path, audio, 16000, subtype='PCM_16')

Распространенная ошибка: использовать aggressive noise reduction. Шумоподавление удаляет именно те артефакты генерации, которые отличают синтезированную речь от натуральной.

2 Параллельный запуск моделей

T-One работает в 4-5 раз быстрее Whisper. Запускаем их параллельно, но с разными чанками. T-One анализирует первые 3 секунды каждого ответа (этого достаточно для детекции артефактов). Whisper обрабатывает полный диалог для контекстного анализа.

import asyncio
from t_one import TOneDetector
from faster_whisper import WhisperModel

class ParallelDetector:
    def __init__(self):
        # T-One модель (последняя версия на февраль 2026)
        self.tone = TOneDetector(model_path="tone-base-2025-12")
        
        # Whisper v3 Large через faster-whisper
        self.whisper = WhisperModel(
            "large-v3",
            device="cuda",
            compute_type="float16"
        )
    
    async def analyze_chunk(self, audio_chunk):
        # T-One на первых 3 секундах
        tone_task = asyncio.create_task(
            self.tone.detect(audio_chunk[:48000])  # 3 сек при 16 кГц
        )
        
        # Whisper на полном аудио
        whisper_task = asyncio.create_task(
            self.whisper.transcribe(audio_chunk)
        )
        
        tone_score, whisper_analysis = await asyncio.gather(
            tone_task, whisper_task
        )
        
        return {
            "tone_score": tone_score,
            "transcript": whisper_analysis[0].text,
            "segments": whisper_analysis[0].segments
        }

3 Извлечение фич из Whisper транскрипта

Текст сам по себе ничего не скажет. Нужны метрики:

• Скорость речи (слогов в секунду). У автоответчиков она неестественно стабильна
• Длительность пауз между фразами. Роботы часто используют фиксированные интервалы
• Повторяемость фраз даже в разных контекстах
• Отсутствие речевых ошибок (никаких "э-э-э", "ну", "как бы")
• Слишком совершенная грамматика в спонтанной речи

def extract_whisper_features(segments):
    """Извлекаем фичи из сегментов Whisper"""
    pauses = []
    speech_rates = []
    
    for i in range(1, len(segments)):
        # Пауза между сегментами
        pause = segments[i].start - segments[i-1].end
        pauses.append(pause)
        
        # Скорость речи в сегменте
        duration = segments[i].end - segments[i].start
        word_count = len(segments[i].text.split())
        
        if duration > 0:
            speech_rates.append(word_count / duration)
    
    # Статистика по паузам
    pause_std = np.std(pauses) if pauses else 0
    
    # Стабильность скорости речи
    rate_std = np.std(speech_rates) if speech_rates else 0
    
    return {
        "pause_regularity": 1 / (1 + pause_std),  # Чем меньше std, тем регулярнее
        "speech_stability": 1 / (1 + rate_std),   # Чем стабильнее, тем выше риск
        "avg_pause": np.mean(pauses) if pauses else 0
    }

Скоринговая модель: как объединить сигналы

T-One дает вероятность синтезированной речи (0-1). Whisper фичи - числовые метрики. Простое усреднение не работает. Нужна калибровка на реальных данных.

import xgboost as xgb
import numpy as np

class Scorer:
    def __init__(self, model_path=None):
        if model_path:
            self.model = xgb.Booster()
            self.model.load_model(model_path)
        else:
            # Параметры актуальны для xgboost 2.1+ (2026 год)
            self.model = xgb.XGBClassifier(
                n_estimators=150,
                max_depth=5,
                learning_rate=0.05,
                subsample=0.8,
                colsample_bytree=0.8,
                use_label_encoder=False,
                eval_metric='logloss'
            )
    
    def prepare_features(self, tone_score, whisper_features):
        """Объединяем все фичи в один вектор"""
        return np.array([
            tone_score,                           # T-One вероятность
            whisper_features['pause_regularity'],
            whisper_features['speech_stability'],
            whisper_features['avg_pause'],
            tone_score * whisper_features['pause_regularity'],  # Взаимодействие
            tone_score * whisper_features['speech_stability']
        ]).reshape(1, -1)
    
    def predict(self, tone_score, whisper_features):
        features = self.prepare_features(tone_score, whisper_features)
        
        if hasattr(self.model, 'predict_proba'):
            proba = self.model.predict_proba(features)[0, 1]
        else:
            # Для booster интерфейса
            dmatrix = xgb.DMatrix(features)
            proba = self.model.predict(dmatrix)[0]
        
        return proba

Пороги и бизнес-логика

Вот где большинство систем спотыкается. Установили порог 0.8 - получили 20% ложных срабатываний. 0.9 - пропускаем половину роботов.

Решение: адаптивные пороги в зависимости от контекста:

• Первые секунды разговора: более строгий порог (0.85). Роботы часто "раскачиваются"
• Техническая поддержка: менее строгий (0.75). Операторы используют шаблонные фразы
• Продажи: строгий порог (0.9). Высокий риск потерять клиента
• Время суток: ночью повышаем чувствительность

class AdaptiveThreshold:
    def __init__(self):
        self.base_threshold = 0.8
        
    def get_threshold(self, context):
        """Адаптивный порог на основе контекста"""
        threshold = self.base_threshold
        
        # Корректировки
        if context['call_type'] == 'sales':
            threshold += 0.1  # 0.9
        elif context['call_type'] == 'support':
            threshold -= 0.05  # 0.75
        
        if context['call_duration'] < 10:  # Первые 10 секунд
            threshold -= 0.05
        
        # Ночные звонки (22:00-06:00)
        if 22 <= context['hour'] <= 23 or 0 <= context['hour'] <= 6:
            threshold -= 0.08
        
        return max(0.5, min(0.95, threshold))  # Ограничиваем разумными пределами

Развертывание в продакшн

Архитектура для обработки 1000+ звонков в час:

# Docker-комpose для продакшн
version: '3.8'

services:
  audio-preprocessor:
    image: python:3.11-slim
    deploy:
      replicas: 3
    resources:
      limits:
        memory: 1G
    command: python preprocessor.py

  tone-detector:
    image: nvidia/cuda:12.2-base
    deploy:
      replicas: 2
    runtime: nvidia
    resources:
      limits:
        memory: 4G
        cpus: '2'
    environment:
      - CUDA_VISIBLE_DEVICES=0

  whisper-detector:
    image: nvidia/cuda:12.2-base
    deploy:
      replicas: 2  # Whisper медленнее, нужно больше инстансов
    runtime: nvidia
    resources:
      limits:
        memory: 12G  # Whisper v3 Large жрет память
        cpus: '4'

  scorer:
    image: python:3.11-slim
    deploy:
      replicas: 4
    resources:
      limits:
        memory: 2G

Критически важный момент: кеширование результатов T-One. Если абонент перезванивает в течение 5 минут, его голосовые характеристики не изменятся. Не нужно запускать детекцию заново.

Мониторинг и false positive анализ

Система запущена. Точность на тестовых данных - 94%. В продакшне - 78%. Классика.

Причины:

1. Новые TTS-системы, не представленные в обучающей выборке
2. Особенности телефонных линий в разных регионах
3. Люди с речевыми особенностями (дикторы, актеры, не носители языка)

Решение: автоматический сбор ложных срабатываний и переобучение раз в неделю.

class FeedbackLoop:
    def __init__(self, storage_path):
        self.storage_path = storage_path
        
    def add_false_positive(self, audio_path, prediction_score, human_verification):
        """Добавляем ложное срабатывание в датасет"""
        metadata = {
            'path': audio_path,
            'predicted_score': prediction_score,
            'actual_label': 0,  # Человек, но система сказала "робот"
            'verification': human_verification,
            'timestamp': datetime.now().isoformat()
        }
        
        # Сохраняем аудио и метаданные
        with open(f"{self.storage_path}/metadata.jsonl", 'a') as f:
            f.write(json.dumps(metadata) + '\n')
        
        # Копируем аудиофайл
        shutil.copy(audio_path, f"{self.storage_path}/audio/")

Что будет дальше: нейросети против детекторов

Гонка вооружений продолжается. Уже появляются TTS-системы, которые специально маскируют артефакты под телефонные шумы. Они добавляют контролируемый шум, микропомехи линии, эмулируют сжатие кодека.

Ответ: мультимодальный анализ. Добавляем:

• Анализ видео (если есть видеозвонок) - синхронность движения губ и речи
• Поведенческий анализ - как быстро абонент реагирует на нестандартные вопросы
• Сетевые метрики - стабильность пинга, характерная для VoIP-роботов

Самый перспективный подход - использовать Voxtral-Mini 4B Realtime для анализа интонационных паттернов в реальном времени. Модель достаточно легкая для запуска на edge-устройствах и дает задержку менее 500ms.

Если вы работаете с большими объемами аудио и нуждаетесь в высокоточных STT-решениях, посмотрите сравнение Qwen3-ASR 1.7B с Whisper v3 Large. Для локального развертывания подойдет глубокий анализ WhisperKit, Whisper.cpp и Scriberr.

Главный урок: не существует silver bullet. T-One ловит артефакты генерации, Whisper анализирует контекст, XGBoost объединяет сигналы. И все это нужно постоянно калибровать на свежих данных. Система, которая сегодня дает 95% точности, через полгода без дообучения будет на уровне 70%.

Начните с пилотного проекта на 1000 звонков. Соберите датасет. Настройте feedback loop. И помните: лучше пропустить робота, чем потерять клиента. Все пороги настраивайте в сторону уменьшения false positive, а не увеличения recall.