SpeechRecognition – распознавание речи

Введение

Современные голосовые помощники, системы транскрипции и голосового управления работают благодаря технологиям распознавания речи. Python предоставляет простой способ интеграции этих технологий через библиотеку SpeechRecognition — гибкий и мощный инструмент для преобразования аудиосигналов в текст.

Библиотека поддерживает как работу с аудиофайлами, так и захват звука с микрофона, а также взаимодействует с различными распознавателями — от локальных решений до облачных API, включая Google, IBM, Sphinx и другие. Эта библиотека стала стандартом для задач распознавания речи в Python благодаря своей простоте использования и универсальности.

Что такое библиотека SpeechRecognition

SpeechRecognition — это популярная Python-библиотека с открытым исходным кодом, разработанная для упрощения интеграции технологий распознавания речи в приложения. Созданная Anthony Zhang, она предоставляет единый интерфейс для работы с множественными движками распознавания речи, что делает её идеальным выбором для разработчиков любого уровня.

Ключевые особенности библиотеки

Библиотека SpeechRecognition выделяется следующими возможностями:

• Кроссплатформенность: работает на Windows, macOS и Linux
• Поддержка множественных API: интеграция с более чем 7 различными сервисами распознавания
• Простота использования: минимальный код для базовых задач
• Гибкость настроек: широкие возможности конфигурации для специфических потребностей
• Активное сообщество: регулярные обновления и поддержка

Архитектура библиотеки

SpeechRecognition построена по модульному принципу, где основные компоненты включают:

• Recognizer — центральный класс для управления распознаванием
• AudioSource — абстракция для источников аудио (файлы, микрофон)
• AudioData — контейнер для аудиоданных
• Engines — адаптеры для различных сервисов распознавания

Установка и настройка зависимостей

Базовая установка

pip install SpeechRecognition

Дополнительные зависимости

Для полноценной работы с различными источниками аудио потребуются дополнительные пакеты:

Для работы с микрофоном:

pip install pyaudio

Для поддержки дополнительных аудиоформатов:

pip install pydub

Для работы с Google Cloud Speech API:

pip install google-cloud-speech

Особенности установки на разных платформах

Windows

На Windows установка pyaudio может вызвать проблемы. Рекомендуется использование предварительно скомпилированных wheel-файлов:

pip install pipwin
pipwin install pyaudio

macOS

brew install portaudio
pip install pyaudio

Linux (Ubuntu/Debian)

sudo apt-get install python3-pyaudio

Импорт и основные компоненты

import speech_recognition as sr

Основные классы и их назначение

• Recognizer() — основной класс для работы с распознаванием речи
• AudioFile() — класс для работы с аудиофайлами
• Microphone() — класс для работы с микрофоном

Работа с аудиофайлами

Поддерживаемые форматы

SpeechRecognition поддерживает следующие аудиоформаты:

• WAV — рекомендуемый формат для лучшего качества
• AIFF — альтернатива WAV
• FLAC — формат без потерь

Базовое распознавание из файла

import speech_recognition as sr

r = sr.Recognizer()

with sr.AudioFile("speech.wav") as source:
    audio = r.record(source)

try:
    text = r.recognize_google(audio, language="ru-RU")
    print("Распознанный текст:", text)
except sr.UnknownValueError:
    print("Аудио не удалось распознать")
except sr.RequestError as e:
    print(f"Ошибка сервиса: {e}")

Работа с длинными аудиофайлами

Для обработки длинных записей рекомендуется разбивать их на сегменты:

r = sr.Recognizer()

with sr.AudioFile("long_speech.wav") as source:
    # Обрабатываем первые 30 секунд
    audio1 = r.record(source, duration=30)
    # Обрабатываем следующие 30 секунд
    audio2 = r.record(source, duration=30, offset=30)

Конвертация MP3 в поддерживаемый формат

from pydub import AudioSegment

# Конвертация MP3 в WAV
audio = AudioSegment.from_mp3("audio.mp3")
audio.export("audio.wav", format="wav")

Работа с микрофоном

Базовое распознавание с микрофона

import speech_recognition as sr

r = sr.Recognizer()
mic = sr.Microphone()

with mic as source:
    r.adjust_for_ambient_noise(source)
    print("Скажите что-нибудь:")
    audio = r.listen(source)

try:
    text = r.recognize_google(audio, language="ru-RU")
    print("Вы сказали:", text)
except sr.UnknownValueError:
    print("Речь не распознана")
except sr.RequestError as e:
    print(f"Ошибка сервиса: {e}")

Выбор конкретного микрофона

# Получение списка доступных микрофонов
print(sr.Microphone.list_microphone_names())

# Использование конкретного микрофона
mic = sr.Microphone(device_index=1)

Непрерывное распознавание

import speech_recognition as sr

r = sr.Recognizer()
m = sr.Microphone()

def callback(recognizer, audio):
    try:
        text = recognizer.recognize_google(audio, language="ru-RU")
        print(f"Распознано: {text}")
    except sr.UnknownValueError:
        pass

# Запуск фонового прослушивания
stop_listening = r.listen_in_background(m, callback)

# Остановка через 30 секунд
import time
time.sleep(30)
stop_listening(wait_for_stop=False)

Обзор поддерживаемых распознавателей

Облачные сервисы

Локальные решения

Специализированные сервисы

Полная таблица методов и функций

Основные методы класса Recognizer

Методы распознавания речи

Свойства класса Recognizer

Методы класса AudioFile

Методы класса Microphone

Обработка ошибок и исключений

Типы исключений

import speech_recognition as sr

try:
    # Код распознавания
    text = r.recognize_google(audio)
except sr.UnknownValueError:
    print("Речь не была распознана")
except sr.RequestError as e:
    print(f"Ошибка сервиса распознавания: {e}")
except sr.WaitTimeoutError:
    print("Превышено время ожидания")
except OSError as e:
    print(f"Ошибка операционной системы: {e}")

Подробное описание исключений

Настройка параметров для улучшения качества

Оптимизация параметров микрофона

r = sr.Recognizer()

# Настройка чувствительности
r.energy_threshold = 4000  # Увеличить для шумных сред
r.dynamic_energy_threshold = True
r.pause_threshold = 1.0  # Длина паузы для завершения фразы

# Настройка таймаутов
r.operation_timeout = 5  # Таймаут операции
r.phrase_threshold = 0.3  # Минимальная длина фразы

Рекомендации по качеству аудио

Для достижения лучших результатов распознавания:

• Частота дискретизации: 16000 Гц или выше
• Разрядность: 16 бит
• Количество каналов: моно (1 канал)
• Формат: WAV без сжатия
• Уровень шума: минимальный фоновый шум
• Расстояние до микрофона: 15-30 см

Предобработка аудио

# Калибровка под окружающий шум
with sr.Microphone() as source:
    r.adjust_for_ambient_noise(source, duration=2)
    print("Калибровка завершена")
    
    audio = r.listen(source, timeout=1, phrase_time_limit=5)

Работа с различными языками

Поддерживаемые языки

SpeechRecognition поддерживает десятки языков. Основные коды языков:

• ru-RU — русский
• en-US — английский (США)
• en-GB — английский (Великобритания)
• de-DE — немецкий
• fr-FR — французский
• es-ES — испанский
• zh-CN — китайский (упрощенный)
• ja-JP — японский

Многоязычное распознавание

# Попытка распознавания на разных языках
languages = ['ru-RU', 'en-US', 'de-DE']

for lang in languages:
    try:
        text = r.recognize_google(audio, language=lang)
        print(f"Распознано на {lang}: {text}")
        break
    except sr.UnknownValueError:
        continue

Практические примеры применения

Создание голосового помощника

import speech_recognition as sr
import pyttsx3

# Инициализация
r = sr.Recognizer()
mic = sr.Microphone()
tts = pyttsx3.init()

def speak(text):
    tts.say(text)
    tts.runAndWait()

def listen():
    with mic as source:
        r.adjust_for_ambient_noise(source)
        audio = r.listen(source)
    
    try:
        command = r.recognize_google(audio, language="ru-RU")
        return command.lower()
    except sr.UnknownValueError:
        return None

# Основной цикл
while True:
    command = listen()
    if command:
        if "время" in command:
            import datetime
            now = datetime.datetime.now()
            speak(f"Сейчас {now.hour} часов {now.minute} минут")
        elif "выход" in command:
            speak("До свидания!")
            break

Транскрипция аудиозаписей

import speech_recognition as sr
import os

def transcribe_audio_file(file_path):
    r = sr.Recognizer()
    
    with sr.AudioFile(file_path) as source:
        audio = r.record(source)
    
    try:
        text = r.recognize_google(audio, language="ru-RU")
        return text
    except sr.UnknownValueError:
        return "Не удалось распознать речь"
    except sr.RequestError as e:
        return f"Ошибка сервиса: {e}"

# Массовая транскрипция файлов
audio_dir = "audio_files"
for filename in os.listdir(audio_dir):
    if filename.endswith(".wav"):
        file_path = os.path.join(audio_dir, filename)
        text = transcribe_audio_file(file_path)
        
        # Сохранение результата
        output_file = filename.replace(".wav", ".txt")
        with open(output_file, "w", encoding="utf-8") as f:
            f.write(text)

Система голосовых команд

import speech_recognition as sr
import subprocess

class VoiceCommandSystem:
    def __init__(self):
        self.r = sr.Recognizer()
        self.mic = sr.Microphone()
        self.commands = {
            "открыть браузер": self.open_browser,
            "открыть калькулятор": self.open_calculator,
            "выключить компьютер": self.shutdown_computer,
        }
    
    def listen_for_command(self):
        with self.mic as source:
            self.r.adjust_for_ambient_noise(source)
            print("Слушаю команду...")
            audio = self.r.listen(source, timeout=5)
        
        try:
            command = self.r.recognize_google(audio, language="ru-RU").lower()
            print(f"Распознана команда: {command}")
            return command
        except sr.UnknownValueError:
            print("Команда не распознана")
            return None
    
    def execute_command(self, command):
        for key, func in self.commands.items():
            if key in command:
                func()
                return True
        return False
    
    def open_browser(self):
        subprocess.run(["start", "chrome"], shell=True)
    
    def open_calculator(self):
        subprocess.run(["calc"], shell=True)
    
    def shutdown_computer(self):
        subprocess.run(["shutdown", "/s", "/t", "10"], shell=True)

# Использование
system = VoiceCommandSystem()
command = system.listen_for_command()
if command and system.execute_command(command):
    print("Команда выполнена")
else:
    print("Команда не найдена")

Оптимизация производительности

Асинхронная обработка

import asyncio
import speech_recognition as sr
from concurrent.futures import ThreadPoolExecutor

async def async_recognize(audio_data, language="ru-RU"):
    loop = asyncio.get_event_loop()
    r = sr.Recognizer()
    
    with ThreadPoolExecutor() as executor:
        text = await loop.run_in_executor(
            executor, 
            r.recognize_google, 
            audio_data, 
            None, 
            language
        )
    return text

# Пример использования
async def main():
    r = sr.Recognizer()
    with sr.AudioFile("speech.wav") as source:
        audio = r.record(source)
    
    text = await async_recognize(audio)
    print(text)

asyncio.run(main())

Кэширование результатов

import hashlib
import pickle
import speech_recognition as sr

class CachedRecognizer:
    def __init__(self):
        self.r = sr.Recognizer()
        self.cache = {}
    
    def _get_audio_hash(self, audio_data):
        return hashlib.md5(audio_data.get_raw_data()).hexdigest()
    
    def recognize_cached(self, audio_data, language="ru-RU"):
        audio_hash = self._get_audio_hash(audio_data)
        
        if audio_hash in self.cache:
            return self.cache[audio_hash]
        
        try:
            text = self.r.recognize_google(audio_data, language=language)
            self.cache[audio_hash] = text
            return text
        except sr.UnknownValueError:
            return None

Часто задаваемые вопросы

Почему не работает распознавание с микрофона?

Основные причины и решения:

• Проверьте установку pyaudio: pip install pyaudio
• Убедитесь, что микрофон не используется другим приложением
• Проверьте разрешения на доступ к микрофону в системе
• Попробуйте указать конкретный device_index для микрофона

Как улучшить точность распознавания?

Рекомендации для повышения точности:

• Используйте качественный микрофон
• Говорите четко и не слишком быстро
• Минимизируйте фоновый шум
• Используйте adjust_for_ambient_noise() перед записью
• Выберите подходящий движок распознавания для вашего языка

Можно ли работать без интернета?

Да, для автономной работы используйте:

• CMU Sphinx: recognize_sphinx()
• Vosk (требует дополнительной установки)
• Whisper от OpenAI (отдельная библиотека)

Как обрабатывать длинные аудиозаписи?

Для длинных записей:

• Разбивайте аудио на сегменты по 30-60 секунд
• Используйте параметр offset для последовательной обработки
• Рассмотрите возможность использования специализированных сервисов для длинных записей

Какой движок выбрать для коммерческого проекта?

Рекомендации по выбору:

• Google Cloud Speech: лучшая точность, масштабируемость
• Microsoft Azure: хорошая интеграция с экосистемой Microsoft
• IBM Watson: сильные возможности настройки
• Amazon Transcribe: для проектов в AWS

Как работать с шумными аудиозаписями?

Методы улучшения качества:

• Используйте предобработку аудио (фильтры шума)
• Настройте параметры energy_threshold
• Применяйте библиотеки для подавления шума (noisereduce)
• Экспериментируйте с разными движками распознавания

Альтернативы и дополнительные инструменты

Современные альтернативы

• OpenAI Whisper: современная нейросеть для распознавания речи
• Wav2Vec2: модель от Facebook для распознавания речи
• DeepSpeech: открытая альтернатива от Mozilla
• Vosk: легковесная библиотека для офлайн-распознавания

Интеграция с другими библиотеками

# Интеграция с pydub для обработки аудио
from pydub import AudioSegment
from pydub.silence import split_on_silence

def transcribe_long_audio(file_path):
    # Загрузка и разбивка аудио
    audio = AudioSegment.from_wav(file_path)
    chunks = split_on_silence(audio, min_silence_len=1000, silence_thresh=-40)
    
    # Распознавание каждого сегмента
    full_text = ""
    for i, chunk in enumerate(chunks):
        chunk.export(f"temp_chunk_{i}.wav", format="wav")
        
        with sr.AudioFile(f"temp_chunk_{i}.wav") as source:
            audio_data = sr.Recognizer().record(source)
            text = sr.Recognizer().recognize_google(audio_data, language="ru-RU")
            full_text += text + " "
    
    return full_text.strip()

Заключение

SpeechRecognition остается одной из самых популярных и удобных библиотек для работы с распознаванием речи в Python. Её главные преимущества — простота использования, широкая поддержка различных движков распознавания и активное сообщество разработчиков.

Библиотека подходит как для быстрого прототипирования, так и для создания серьезных коммерческих приложений. Разнообразие поддерживаемых API позволяет выбрать оптимальное решение для любых требований — от бесплатных сервисов для личных проектов до высокоточных платных решений для enterprise-приложений.

Для начала работы достаточно нескольких строк кода, но при необходимости библиотека предоставляет глубокие возможности настройки и оптимизации. В сочетании с современными подходами к обработке аудио и машинному обучению, SpeechRecognition может стать основой для создания сложных систем голосового взаимодействия.