Python работа с микрофоном в реальном времени

Вы когда-нибудь задумывались о том, как Google Assistant или Amazon Alexa распознает все, что вы говорите? Помимо огромного успеха на рынке систем распознавания, большая часть сотовых устройств имеет функцию распознавания речи через некоторые встроенные приложения или сторонние приложения.

Не обязательно, но большинство таких систем распознавания речи построено и развернуто с помощью пакетов и библиотек python. В определенной степени Python доказал, что это важный аспект обозримого будущего. Причина довольно очевидна. Чтобы включить распознавание речи в Python, вам потребуется определенный уровень интерактивности и доступности, соответствующий технологиям.

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

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

Как работает распознавания речи?

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

Распознавание речи возникло в результате исследований, проведенных Bell Labs еще в 1950 году, с ограничениями только для одного говорящего и с ограниченной базой словарного запаса. Современные приложения для распознавания речи прошли долгий путь с момента появления древних аналогов.

Говоря о составляющих, первая из них – это речь. Она должна быть преобразована из звука в сигнал, который может проходить через микрофон и может быть преобразована в цифровые данные. Это делается с помощью аналого-цифрового преобразователя. После того, как данные оцифрованы, несколько моделей могут легко преобразовать звук в текст.

Современные распознаватели речи основаны на менее известной концепции Hidden Markov Model (HMM). Подход основан на предположениях, сформулированных для речевого сигнала, когда он сохраняется в течение короткого периода (скажем, пять миллисекунд), и его можно назвать стационарным процессом, то есть процессом, основанным на статистике, которая не меняется с течением времени.

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

Размеры отображаемого вектора довольно малы, всего 10, по сравнению с некоторыми точными системами, которые могут иметь размеры, достигающие 32 или более. Сгенерированный окончательный результат HMM принимает форму векторных последовательностей.

Группа векторов играет важную роль в декодировании речи в текст с помощью фонем, которые являются основными единицами речи. Вычисление фонем зависит от обучения, так как говорящие различаются, и даже у одного и того же говорящего иногда бывает разное произношение. Поэтому, чтобы справиться с этой проблемой, рассматривается специальный алгоритм, определяющий наиболее относительные слова, образующие последовательность фонем.

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

Кроме того, детекторы голосовой активности (VAD) также используются для уменьшения некоторой части аудиосигнала, которая может содержать речь. В основном он используется для распознавания неважных частей речи и предотвращения их принятия во внимание.

Пакеты распознавания речи

В цепочке PyPI существует несколько пакетов для распознавания речи. Вот некоторые из них:

1. Assembly
2. Apia
3. SpeechRecognition
4. Wit
5. Watson-developer-cloud

Вышеуказанные пакеты, такие как apiai и wit, предлагают функцию обработки естественного языка. Эта встроенная функция помогает определить намерения говорящего и выходит за рамки обычного распознавания речи. Другие пакеты в основном ориентированы на преобразование речи в текст.

Из вышеперечисленных пакетов выделяется только один пакет – SpeechRecognition.

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

Библиотека SpeechRecognition ведет себя как обложка или оболочка для различных API, созданных исключительно для речи. Он невероятно гибкий и маневренный. Одним из таких API является API Google Web Speech, который поддерживает жестко заданное распознавание речи по умолчанию.

Библиотека SpeechRecognition очень проста в использовании, а пакет легко импортировать как проект python. Также важно отметить, что этот пакет может не включать в себя все API, доступные сегодня. Таким образом, вам нужно точно определить, какой пакет вам нужен для создания распознавателя речи.

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

Установка SpeechRecognition

Пакет SpeechRecognition совместим с различными версиями языка Python, такими как 2.6, 2.7 и 3.3+. Также могут потребоваться другие установки, если ваша версия python устарела. Предполагая, что у вас есть версия Python 3.3+ в вашей локальной системе, вы можете выполнить метод установки с терминала с помощью pip.

 
  $ pip install SpeechRecognition 

После установки вы должны проверить, правильно ли интерпретируется установка, используя следующий код, приведенный ниже.

 
 >>> import speech_recognition as sr 
>>> sr._version_'3.8.1' 

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

Класс распознавателя

Магия SpeechRecognition проявляется только в присутствии класса Recognizer. Основная цель Recognizer – распознавать речь вместе с вариантами чтения различных речей, а затем управлять функциями и проверять речь, исходящую от источника звука.

Чтобы создать распознаватель, вам нужно создать его экземпляр. Итак, введите приведенный ниже код в интерпретатор Python.

 
  >>> r=sr.Recognizer() 

Существуют различные методы создания экземпляров Recognizer, которые могут распознавать речь из источника звука с поддержкой API. Некоторые из них перечислены ниже.

 
recognize_bing(): Microsoft Bing Speech 
 
recognize_google(): Google Web Speech API 
 
recognize_google_cloud(): Google Cloud Speech - requires  
installation of the google-cloud-speech package 
 
recognize_houndify(): Houndify by SoundHound 
 
recognize_ibm(): IBM Speech to Text 
 
recognize_sphinx(): CMU Sphinx - requires installing PocketSphinx 
 
recognize_wit(): Wit.ai 

Из этих пакетов, пакет распознавания_sphinx() предназначен для работы в автономном режиме при использовании с CMU Sphinx Engine. Остальным пакетам для работы требуется подключение к Интернету.

Примечание: важно быть осторожным с ключом по умолчанию, предоставленным в SpeechRecognition. Он в основном используется для тестирования и в целях безопасности, и он может быть отозван Google. Таким образом, SpeechRecognition имеет интерфейс API, который может переводить эти ключи по умолчанию для осторожного использования.

Метод each_recognize _ *() может вызвать исключение с именем speech_recognition.RequestError exception. Это могло произойти из-за того, что API может быть недоступен из-за поврежденной установки. Для остальных методов, показанных выше, RequestError может быть сгенерирован, если достигнуты лимиты в рамках их квоты, или если имеются проблемы с сервером или подключением к Интернету. Может возникнуть проблема, которая выглядит примерно так.

 
 Traceback(most recent call last): 
  File "", line 1, in  
TypeError: recognize_google() missing 1 required positional argument: 'audio_data' 

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

Перед тем как приступить к работе с пакетом SpeechRecognition в Python, вам сначала необходимо загрузить аудиофайл. SpeechRecognition упрощает работу с аудиофайлами, сохраняя их в том же каталоге интерпретатора Python, который вы используете в данный момент. Это делается с помощью класса AudioFile. Этот класс необходимо инициализировать и указать путь к аудиофайлу, чтобы диспетчер контекста предоставлял удобный интерфейс для чтения файлов и их содержимого.

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

Типы форматов файлов, которые поддерживает SpeechRecognition, указаны ниже:

1. WAV: формат должен быть в PCM / LPCM
2. AIFF
3. AIFF-C
4. FLAC: формат должен быть собственным FLAC

Если у вас Windows, Linux или macOS на базе x-86, работать с файлами FLAC проще. Помимо этих операционных систем, вам может потребоваться установить кодировщик FLAC, который даст доступ к инструменту командной строки.

Сбор данных с помощью record()

Функция record() используется для захвата данных из файла с помощью интерпретатора python в вашем файле. Например, имя файла – «harvard.wav», код интерпретатора Python для кодирования этого метода будет следующим.

 
  >>> hardvard = sr.AudioFile('harvard.wav') 
 >>> with harvard as source: 
         Audio = r.record(source) 

Этот код откроет диспетчер контекста для чтения содержимого файла и сохранит данные в экземпляре AudioFile, известном как источник. Затем метод record() запишет реальные данные из файла. Чтобы убедиться, что данные записаны, вы можете проверить это с помощью следующего кода.

 
  >>> type(audio) 
    

В качестве альтернативы вы также можете вызвать распознавание_google(), чтобы звук распознавался. Это может зависеть от скорости вашего интернета, от того, как записывается звук и сколько секунд отображаются результаты.

 
  >>> r.recognize_google(audio) 

Этот код будет транскрибировать все данные, присутствующие в файле, и записывать распознанный звук в текстовом формате.

Захват длительности и смещения сегмента

Если вы хотите записать в файл только определенный фрагмент речи, метод record() может сделать это, распознав ключевое слово duration, за которым следует аргумент, который останавливает речь через несколько секунд. Например, вам может потребоваться захватить первые 5 секунд речи из файла «harvard.wav»; вы можете сделать это, используя следующий метод, указанный ниже.

 
  >>> with harvard as source: 
          Audio = r.record(source, duration=5) 
 >> >r.recognize_google(audio) 

При использовании внутри блока, метод record() всегда намеревается продвигаться вперед в файловом потоке. Обычно это означает, что запись повторяется в течение четырех секунд и возвращает первый четырехсекундный звук, если вы записываете в течение первых четырех секунд. Это явление можно проиллюстрировать с помощью фрагмента кода, приведенного ниже.

 
  >>> with harvard as source: 
...     audio1 = r.record(source, duration=4) 
...     audio2 = r.record(source, duration=4) 
... 
>>> r.recognize_google(audio1) 
'the stale smell of old beer lingers' 
 
>>> r.recognize_google(audio2) 
'it takes heat to bring out the odor a cold dip.' 

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

Кроме того, при указании метода record() вы даже можете установить конкретную начальную точку, используя аргумент через ключевое слово offset. Начальная точка представляет собой количество секунд от файла до начала записи. Таким образом, чтобы захватить вторую фразу из аудиофайла, вы можете выбрать 5 или 3 секунды в зависимости от ваших потребностей, используя метод ниже.

 
  >>> with harvard as source: 
...     audio = r.record(source, offset=4, duration=3) 
... 
>>> r.recognize_google(audio) 

Важность ключевого слова длительности и смещения падает на сегментацию файла, содержащего звук. Если вы уже знаете звуковые кадры, вы можете столкнуться с неточной транскрипцией. Чтобы визуализировать этот эффект, используйте следующий код, попробовав интерпретатор Python.

 
>>> with harvard as source: 
...     audio = r.record(source, offset=4.7, duration=2.8) 
... 
>>> r.recognize_google(audio) 

В приведенном выше фрагменте кода указано, что запись начинается через 4,7 секунды, и начальная фраза будет пропущена. Точно так же, когда запись закончится, захваченная фраза не будет соответствовать фазе начала.

Еще одна причина пропуска фраз, которая приводит к неточной транскрипции, – это шум. Чистый звук может хорошо работать, но в реальном мире нет такого места без шума.

Влияние шума на распознавание речи

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

Чтобы понять, как шум влияет на распознавание речи, вам необходимо загрузить файл с именем «jackhammer.wav» и убедиться, что он сохранен в рабочем каталоге интерпретатора. Предполагая, что в этом файле громко произносится фраза «JavaTpoint – лучший сайт обучения java», вам необходимо записать ее в фоновом режиме. Для этого рассмотрим метод ниже.

 
>>> jackhammer = sr.AudioFile('jackhammer.wav') 
>>> with jackhammer as source: 
...     audio = r.record(source) 
... 
>>> r.recognize_google(audio) 

Чтобы справиться с шумом, можно попробовать еще один метод после вышеуказанного шага – использовать метод adjust_for_ambient_noise() класса Recognizer.

 
>>> with jackhammer as source: 
...     r.adjust_for_ambient_noise(source) 
...     audio = r.record(source) 
... 
>>> r.recognize_google(audio) 

В приведенном выше фрагменте кода отсутствует начальный вывод, а вывод печатается без первого слова. Следовательно, когда метод record() захватывает звук, первая часть аудиофайла потребляется, а последующие данные захватываются. Метод adjust_for_ambient_noise() считывает первую секунду аудиофайла, а Recognizer калибрует уровень шума аудио.

Если вы хотите настроить временные рамки с помощью adjust_for_ambient_noise(), вы можете использовать ключевое слово duration во фрагменте кода, присвоив ему числовое значение в секундах. Если вы не присваиваете никакого значения, по умолчанию принимается одно значение, но рекомендуется уменьшить его до 0,5. Следующий фрагмент кода демонстрирует ту же технику.

 
>>> with jackhammer as source: 
...     r.adjust_for_ambient_noise(source, duration=0.5) 
...     audio = r.record(source) 
... 
>>> r.recognize_google(audio) 

Приведенный выше фрагмент кода вернет весь аудиофайл, который вы ранее пропустили в начале. Хотя в некоторых случаях очень сложно обработать или устранить эффект шума, потому что сигнал может быть слишком шумным, чтобы с ним можно было справиться.

Поэтому вам, возможно, придется прибегнуть к другим методам предварительной обработки звука для решения такой проблемы. Для этого вы можете использовать программное обеспечение для редактирования аудио или пакет Python, например SciPy. Пакет может предварительно обработать аудиофайл и отфильтровать шум.

Кроме того, при работе с зашумленными файлами полезно использовать фактический ответ API, поскольку большинство API возвращают строки JSON с множеством транскрипций.

Точно так же метод распознавания_google() обязан доставить аналогичные зашифрованные файлы, если только он не принудительно доставляет полный ответ. Этот метод может быть практически реализован с использованием определенных аргументов и ключевых слов, таких как show_all, который возвращается для метода accept_google().

 
  >>> r.recognize_google(audio, show_all=True) 
{'alternative': [ 
  {'transcript': 'javatpoint best is the programming site'},  
  {'transcript': 'the javatpoint site is best programming'},  
  {'transcript': 'javatpoint programming is the best site'}, 
  {'transcript': 'the programming is javatpoint best site'},  
  {'transcript': 'best is the programming site javatpoint'},  
], 'final': True} 

В приведенном выше фрагменте кода метод accept_google() возвращает словарь с альтернативным ключом, который указывает на различные транскрипции, показанные выше. Хотя структура ответа может иметь разные формы из-за различий от API к API, она в основном используется для отладки.

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

Тренировка с микрофонным входом

Вы можете получить доступ к своему микрофону с помощью пакета SpeechRecognizer, установив пакет с именем PyAudio. Для этого сохраните текущие изменения и закройте интерпретатор. Затем установите PyAudio с помощью того же процесса, что и для SpeechRecognizer.

 
$ pip install pyaudio 

После установки, чтобы проверить, совместима ли она с используемой версией распознавателя речи, введите следующую команду.

 
$ python -m speech_recognizer 

После этого шага вам необходимо убедиться, что ваш микрофон по умолчанию включен и не приглушен. Если вы не столкнулись с какими-либо проблемами при установке и тестировании, вы должны увидеть что-то подобное на терминале.

 
A moment of silence, please? 
Set minimum energy threshold to 600.4452854381937 
Say something! 

Попробуйте поиграть, опробовав микрофон и проверив, как пакет SpeechRecognizer расшифровывает вашу речь.

Класс микрофона

Класс микрофона используется для создания экземпляра системы для распознавания аудиофайла из источника. Чтобы использовать этот класс, вам необходимо импортировать его, открыв другой сеанс интерпретатора и создав класс распознавателя, как показано ниже.

 
>>> import speech_recognizer as sr 
>>> r.=sr.Recognizer() 

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

 
>>> mic = sr.Microphone() 

Если вы не можете распознать микрофон по умолчанию вашей системы, вам может потребоваться указать один из индексов устройства. Вы можете получить список всех доступных имен микрофонов с помощью метода list_microphone_names() в классе микрофона.

 
>>> sr.Microphone.list_microphone_names() 
['HDA Intel PCH: ALC272 Analog(hw:0,0)', 
 'HDA Intel PCH: HDMI 0(hw:0,3)', 
 'sysdefault', 
 'front', 
 'surround40', 
 'surround51', 
 'surround71', 
 'hdmi', 
 'pulse', 
 'dmix',  
 'default'] 

Индекс устройства, определенный в приведенном выше коде, известен как индекс, содержащий список доступных имен микрофонов в системе. Например, в приведенном выше выводе микрофон с названием «передний» расположен в списке под индексом 3. Это можно сделать с помощью метода, приведенного ниже.

 
 >>> mic = sr.Microphone(device_index=3) 

Код является всего лишь примером, поэтому его не рекомендуется запускать в интерпретаторе. Для большинства проектов следует использовать системный микрофон по умолчанию.

Ввод микрофона с помощью listen()

Другой метод, который вы здесь изучите, – это метод listen(), используемый для захвата ввода с микрофона. Поскольку вы уже создали экземпляр микрофона, самое время сделать ввод.

Как и большинство классов AudioFile, микрофон также рассматривается как диспетчер контекста. Он захватывает ввод через класс Recognizer, имеющий внутри блок, принимая его в качестве первого аргумента, а затем записывает ввод из источника до момента, когда микрофон обнаруживает тишину. Чтобы обрисовать это, давайте посмотрим, как это применяется с использованием данного кода.

 
  >>> with mic as source: 
...     audio = r.listen(source) 
... 

После того, как приведенный выше код будет выполнен с блоком, вы должны попробовать что-то сказать в микрофон и подождать некоторое время. Через некоторое время интерпретатор может предложить отобразить. Как только вы увидите “>>>” в качестве возвращенного приглашения, это означает, что распознаватель сможет распознать все, что вы говорите.

Если Recognizer не возвращает подсказку, возможно, слышен некоторый внешний шум. Вы можете остановить это, нажав Ctrl + C, чтобы запросить ответ.

Чтобы настроить шум, преобладающий в вашей речи, вам может потребоваться использовать тот же метод adjust_for_ambient_noise() класса Recognizer. Поскольку вход микрофона непредсказуем по сравнению с аудиофайлом, всегда рекомендуется делать это во время прослушивания входного сигнала микрофона. Чтобы получить точный и бесшумный вывод, вы можете попробовать его с помощью метода listen(), как показано.

 
  >>> with mic as source: 
...     r.adjust_for_ambient_noise(source) 
...     audio = r.listen(source) 
... 

При запуске кода подождите несколько секунд, чтобы метод adjust_for_ambient Noise() выполнил свои задачи. После того, как код скомпилирован и запущен, попробуйте сказать что-нибудь в микрофон и подождите, пока переводчик распознает речь. Если он распознает и возвращает приглашение, значит, он работает нормально.

Вы также можете использовать ключевое слово duration и попытаться использовать его снова для получения определенного кадра речи, которую хотите распознать. Между тем, документация SpeechRecognizer рекомендует использовать ключевое слово duration, если оно имеет продолжительность 0,5 или меньше.

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

Нераспознаваемая речь

С помощью thebcodebase вы создали в интерпретаторе ощутимый код, используя микрофон, чтобы добавить неразборчивые шумы. Совершенно очевидно, что вы можете получить подобное сообщение об ошибке.

 
  Traceback(most recent call last): 
  File "", line 1, in  
  File  
 
"/home/david/real_python/speech_recognition_primer/venv/lib/pyth 
on3.5/site-packages/speech_recognition/__init__.py", line 858, in recognize_google 
if not isinstance(actual_result, dict) or  
len(actual_result.get("alternative", [])) == 0: raise  
UnknownValueError() 
speech_recognition.UnknownValueError 

Эта ошибка возникает из-за нераспознанного характера речи, захваченной через микрофон в качестве входной, и, следовательно, кодовая база API недостаточно развита, чтобы транскрибировать эти короткие посторонние шумы или звуки голоса.

Также может быть случай, когда переводчик может подсказывать, распознавая текущий ввод и отображая что-то, даже не близкое к тому, что было захвачено через микрофон. Следовательно, такие действия, как хлопки в ладоши, щелчки или другие полосы, могут вызвать исключение или неправильный вывод, соответственно.

Резюме

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

Вы также узнали о некоторых критических методах решения проблемы, которая обычно возникает при использовании пакета SpeechRecognizer, и выяснили, как исправить эти проблемы.

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

I’m trying to read, in near-realtime, the volume coming from the audio of a USB microphone in Python.

I have the pieces, but can’t figure out how to put it together.

If I already have a .wav file, I can pretty simply read it using wavefile:

from wavefile import WaveReader

with WaveReader("/Users/rmartin/audio.wav") as r:
    for data in r.read_iter(size=512):
        left_channel = data[0]
        volume = np.linalg.norm(left_channel)
        print volume

This works great, but I want to process the audio from the microphone in real-time, not from a file.

So my thought was to use something like ffmpeg to PIPE the real-time output into WaveReader, but my Byte knowledge is somewhat lacking.

import subprocess
import numpy as np

command = ["/usr/local/bin/ffmpeg",
            '-f', 'avfoundation',
            '-i', ':2',
            '-t', '5',
            '-ar', '11025',
            '-ac', '1',
            '-acodec','aac', '-']

pipe = subprocess.Popen(command, stdout=subprocess.PIPE, bufsize=10**8)
stdout_data = pipe.stdout.read()
audio_array = np.fromstring(stdout_data, dtype="int16")

print audio_array

That looks pretty, but it doesn’t do much. It fails with a [NULL @ 0x7ff640016600] Unable to find a suitable output format for ‘pipe:’ error.

I assume this is a fairly simple thing to do given that I only need to check the audio for volume levels.

Anyone know how to accomplish this simply? FFMPEG isn’t a requirement, but it does need to work on OSX & Linux.

Включение распознавания речи в ваше приложение Python обеспечивает интерактивность.

Вы узнаете:

• Как работает распознавание речи,
• Какие Библиотеки необходимы
• Как установить и использовать пакет SpeechRecognition — полнофункциональную и простую в использовании библиотеку распознавания речи Python.

Как работает распознавание речи

Современные системы распознавания речи могут распознавать речь от нескольких носителей и имеют огромный словарный запас на разных языках.

Речь должна быть преобразована из физического звука в электрический сигнал с помощью микрофона, а затем в цифровые данные можно использовать для транскрибирования аудио в текст.

Выбор пакета распознавания речи Python

В PyPI существует несколько пакетов для распознавания речи. Некоторые из них включают в себя:

• apiai
• assemblyai
• google-cloud-speech
• pocketsphinx
• SpeechRecognition
• watson-developer-cloud
• wit

Некоторые из этих пакетов, такие как wit и apiai, предлагают встроенные функции, такие как обработка на естественном языке для определения намерений говорящего, которые выходят за рамки базового распознавания речи. Другие, такие как google-cloud-speech, сосредоточены исключительно на преобразовании речи в текст.

SpeechRecognition: — пакет, позволяет создавать сценарии для доступа к микрофонам и обработки аудиофайлов с нуля.

Библиотека SpeechRecognition действует как оболочка для нескольких популярных речевых API и, таким образом, является чрезвычайно гибкой.

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

Установка SpeechRecognition

SpeechRecognition совместим с Python 3.3+.

Установить SpeechRecognition из терминала с помощью pip:

$ pip install SpeechRecognition

После установки вы должны проверить установку, открыв сеанс интерпретатора и набрав:

>>> import speech_recognition as sr
>>> sr.__version__
'3.8.1'

Примечание. Номер получаемой вами версии может отличаться.

SpeechRecognition будет работать из коробки, если все, что вам нужно, это работать с существующими аудио-файлами. Однако конкретные случаи использования требуют нескольких зависимостей. В частности, пакет PyAudio необходим для захвата микрофонного входа.

The Recognizer Class

Основной целью экземпляра Recognizer, является распознавание речи. Каждый экземпляр поставляется с различными настройками и функциями для распознавания речи из аудио-источника.

Создать экземпляр Recognizer очень просто:

Каждый экземпляр Recognizer имеет семь методов для распознавания речи из аудио-источника с использованием различных API:

• recognize_bing(): Microsoft Bing Speech
• recognize_google(): Google Web Speech API
• recognize_google_cloud(): Google Cloud Speech — требует установки пакета google-cloud-speech package
• recognize_houndify(): Houndify by SoundHound
• recognize_ibm(): IBM Speech to Text
• recognize_sphinx(): CMU Sphinx — требует установки PocketSphinx
• recognize_wit(): Wit.ai

Из семи только recognize_sphinx() работает в автономном режиме с движком CMU Sphinx. Остальные шесть требуют подключения к интернету.

Поскольку SpeechRecognition поставляется с ключом API по умолчанию для Google Web Speech API, вы можете сразу начать работу с ним. По этой причине мы будем использовать Web Speech API. Все остальные шесть API-интерфейсов требуют аутентификации либо по ключу API, либо по комбинации имени пользователя и пароля. Дополнительная информация в документации SpeechRecognition.

Каждый метод распознавания генерирует исключение speech_recognition. RequestError, если API недоступен. Для recognize_sphinx() это может произойти в результате отсутствующей, поврежденной или несовместимой установки Sphinx. Для других шести методов RequestError может быть сгенерирован, если соблюдены ограничения квоты, сервер недоступен или отсутствует подключение к Интернету.

Попробуйте вызвать recognize_google():

Получили что-то похожее на это:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: recognize_google() missing 1 required positional argument: 'audio_data'

Все семь методов распознавания класса Recognizer требуют аргумент audio_data. В каждом случае audio_data должен быть экземпляром класса AudioData SpeechRecognition.

Существует два способа создания экземпляра AudioData: из аудио-файла или аудио, записанного микрофоном.

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

Прежде чем продолжить, вам необходимо скачать аудио-файл. Убедитесь, что вы сохранили его в том же каталоге, в котором работает сеанс интерпретатора Python.

SpeechRecognition облегчает работу с аудио-файлами благодаря удобному классу AudioFile. Этот класс может быть инициализирован путем указания пути к аудио-файлу и предоставляет интерфейс диспетчера контекста для чтения и работы с содержимым файла.

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

• WAV: должен быть в формате PCM/LPCM
• AIFF
• AIFF-C,
• FLAC: должен быть родным форматом FLAC; OGG-FLAC не поддерживается

Если вы работаете на Linux, MacOS или Windows на основе x-86, вы сможете без проблем работать с файлами FLAC.

Использование record() для захвата данных из файла

Введите в следующую команду для обработки содержимого файла:

harvard = sr.AudioFile('harvard.wav')
with harvard as source:
    audio = r.record(source)

Диспетчер контекста открывает файл и считывает его содержимое, сохраняя данные в экземпляре AudioFile, называемом source. Затем метод record() записывает данные из всего файла в экземпляр AudioData. Вы можете подтвердить это, проверив тип аудио:

print(type(audio))     # <class 'speech_recognition.AudioData'>

Теперь вы можете вызвать accept_google(), чтобы попытаться распознать любую речь в аудио. В зависимости от скорости вашего интернет-соединения, вам может потребоваться подождать несколько секунд, прежде чем вы увидите результат.

print(r.recognize_google(audio))

'the stale smell of old beer lingers it takes heat to bring out the odor a cold dip restores health and zest a salt pickle taste fine with ham tacos al Pastore are my favorite a zestful food is the hot cross bun'

Поздравляем! Вы только что распознали первый аудиофайл!

Захват сегментов со смещением и продолжительностью

Что если вы хотите захватить только часть речи в файле? Метод record() принимает аргумент продолжительности ключевого слова, который останавливает запись через указанное количество секунд.

Например, следующее фиксирует любую речь в первые четыре секунды файла:

with harvard as source:
     audio = r.record(source, duration=4)

print(r.recognize_google(audio))        # 'the stale smell of old beer lingers'

Метод record() при использовании внутри блока with всегда перемещается в файловом потоке. Это означает, что если вы записываете один раз в течение четырех секунд, а затем снова записываете в течение четырех секунд, второй раз возвращает четыре секунды звука после первых четырех секунд.

```py
with harvard as source:
    audio1 = r.record(source, duration=4)
    audio2 = r.record(source, duration=4)

r.recognize_google(audio1)      # 'the stale smell of old beer lingers'
r.recognize_google(audio2)      # 'it takes heat to bring out the odor a cold dip'

Обратите внимание, что audio2 содержит часть третьей фразы в файле. При указании длительности запись может останавливаться в середине фразы или даже в середине слова, что может повлиять на точность транскрипции. Подробнее об этом чуть позже.

Помимо указания продолжительности записи, методу record() может быть задана конкретная начальная точка с помощью аргумента смещения ключевого слова. Это значение представляет количество секунд от начала файла, которое нужно проигнорировать перед началом записи.

Чтобы захватить только вторую фразу в файле, вы можете начать со смещения в четыре секунды и записывать, три секунды.

with harvard as source:
    audio = r.record(source, offset=4, duration=3)

print(recognizer.recognize_google(audio))       # 'it takes heat to bring out the odor'

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

with harvard as source:
    audio = r.record(source, offset=4.7, duration=2.8)

print(recognizer.recognize_google(audio))       # 'Mesquite to bring out the odor Aiko'

Начав запись через 4.7 секунды, вы пропускаете часть «it t» в начале фразы «it takes heat to bring out the odor», поэтому API получил только «akes heat», что соответствует «Mesquite.»

Точно так же, в конце записи вы записали «co», которое является началом третьей фразы «a cold dip restores health and zest». Это было сопоставлено с «Aiko» API.

Есть еще одна причина, по которой вы можете получить неточные записи. Шум! Приведенные выше примеры хорошо работали, потому что аудиофайл достаточно чистый. В реальном мире, если у вас нет возможности обработать аудиофайлы заранее, вы не можете ожидать, что звук будет свободным от шума.

Влияние шума на распознавание речи

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

Чтобы понять, как шум может повлиять на распознавание речи, загрузите файл «jackhammer.wav» здесь. Убедитесь, что вы сохранили это в рабочем каталоге сеанса переводчика.

В этом файле есть фраза «нthe stale smell of old beer lingers», на котором громкий отбойный молоток на заднем плане.

Что происходит, когда вы пытаетесь расшифровать этот файл?

jackhammer = sr.AudioFile('jackhammer.wav')
with jackhammer as source:
    audio = r.record(source)

print(r.recognize_google(audio))    # 'the snail smell of old gear vendors'

Cправляетесь с этим? Одна вещь, которую вы можете попробовать, это использовать метод adjust_for_ambient_noise() класса Recognizer.

with jackhammer as source:
    r.adjust_for_ambient_noise(source)
    audio = r.record(source)

print(r.recognize_google(audio))    # 'still smell of old beer vendors'

Это немного приблизило вас к настоящей фразе, но она все еще не идеальна. Кроме того, «the» отсутствует в начале фразы. Почему это?

Метод adjust_for_ambient_noise() считывает первую секунду потока файла и калибрует распознаватель по уровню шума звука. Следовательно, эта часть потока используется перед вызовом record() для захвата данных.

Вы можете настроить временной интервал, который adjust_For_ambient_noise() использует для анализа с аргументом ключевого слова duration. Этот аргумент принимает числовое значение в секундах и по умолчанию равен 1. Попробуйте уменьшить это значение до 0,5.

with jackhammer as source:
    r.adjust_for_ambient_noise(source, duration=0.5)
    audio = r.record(source)

print(r.recognize_google(audio))    # 'the snail smell like old Beer Mongers'

Хорошо, это дало вам «the» фразы, но теперь у вас есть новые проблемы! Иногда невозможно устранить влияние шума — сигнал слишком шумный, чтобы с ним можно было успешно справиться. Так обстоит дело с этим файлом.

Если вы часто сталкиваетесь с этими проблемами, вам, возможно, придется прибегнуть к некоторой предварительной обработке аудио. Это можно сделать с помощью программного обеспечения для редактирования аудио или пакета Python (такого как SciPy), который может применять фильтры к файлам. На данный момент, просто имейте в виду, что окружающий шум в аудиофайле может вызвать проблемы и должен быть устранен, чтобы максимизировать точность распознавания речи.

При работе с зашумленными файлами может быть полезно увидеть фактический ответ API. Большинство API возвращают строку JSON, содержащую много возможных транскрипций. recognize_google() всегда будет возвращать наиболее вероятную транскрипцию, если вы не заставите ее дать полный ответ.

Вы можете сделать это, установив для аргумента ключевого слова show_all метода recognize_google() значение True.

print(r.recognize_google(audio, show_all=True))

Результат вывода:

{'alternative': [
  {'transcript': 'the snail smell like old Beer Mongers'},
  {'transcript': 'the still smell of old beer vendors'},
  {'transcript': 'the snail smell like old beer vendors'},
  {'transcript': 'the stale smell of old beer vendors'},
  {'transcript': 'the snail smell like old beermongers'},
  {'transcript': 'destihl smell of old beer vendors'},
  {'transcript': 'the still smell like old beer vendors'},
  {'transcript': 'bastille smell of old beer vendors'},
  {'transcript': 'the still smell like old beermongers'},
  {'transcript': 'the still smell of old beer venders'},
  {'transcript': 'the still smelling old beer vendors'},
  {'transcript': 'musty smell of old beer vendors'},
  {'transcript': 'the still smell of old beer vendor'}
], 'final': True}

Как вы можете видеть, recognize_google() возвращает словарь с ключом «альтернатива», который указывает на список возможных расшифровок. Структура этого ответа может варьироваться от API к API и в основном полезна для отладки.

К настоящему времени у вас есть довольно хорошее представление об основах пакета SpeechRecognition. Вы видели, как создать экземпляр AudioFile из аудиофайла и использовать метод record() для захвата данных из файла. Вы узнали, как записывать сегменты файла, используя аргументы смещения и длительности ключевого слова record(), и испытали пагубное влияние шума на точность транскрипции.

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

Чтобы получить доступ к микрофону с помощью SpeechRecognizer, вам необходимо установить пакет PyAudio.

Установка PyAudio в Windows

В Windows вы можете установить PyAudio с помощью pip:

Тестирование установки

После установки PyAudio вы можете проверить установку с консоли.

$ python -m speech_recognition

Убедитесь, что ваш микрофон по умолчанию включен. Если установка сработала, вы должны увидеть что-то вроде этого:

A moment of silence, please...
Set minimum energy threshold to 600.4452854381937
Say something!

Поговорив в микрофон и посмотрите, насколько хорошо SpeechRecognition транскрибирует вашу речь.

Класс микрофона

Теперь вместо использования аудиофайла в качестве источника вы будете использовать системный микрофон по умолчанию. Вы можете получить к нему доступ, создав экземпляр класса Microphone.

import speech_recognition as sr
r = sr.Recognizer()
mic = sr.Microphone()

Если в вашей системе нет микрофона по умолчанию, или вы хотите использовать микрофон, отличный от стандартного, вам нужно будет указать, какой из них использовать, указав индекс устройства. Вы можете получить список имен микрофонов, вызвав статический метод list_microphone_names() класса Microphone.

sr.Microphone.list_microphone_names()
['HDA Intel PCH: ALC272 Analog (hw:0,0)',
 'HDA Intel PCH: HDMI 0 (hw:0,3)',
 'sysdefault',
 'front',
 'surround40',
 'surround51',
 'surround71',
 'hdmi',
 'pulse',
 'dmix',
 'default']

Обратите внимание, что ваш вывод может отличаться от приведенного выше примера.

Индекс устройства микрофона — это индекс его имени в списке, возвращаемом функцией list_microphone_names(). Например, учитывая вышеприведенный вывод, если вы хотите использовать микрофон с именем «front», который имеет индекс 3 в списке, вы должны создать экземпляр микрофона, например:

# Это всего лишь пример
mic = sr.Microphone(device_index = 3)

Тем не менее, для большинства проектов вы, вероятно, захотите использовать системный микрофон по умолчанию.

Использование listen() для ввода с микрофона

Теперь, когда у вас есть готовый экземпляр Microphone, пришло время захватить некоторые данные.

Как и класс AudioFile, Microphone является контекстным менеджером. Вы можете захватить ввод с микрофона, используя метод listen() класса Recognizer внутри блока with. Этот метод принимает источник звука в качестве первого аргумента и записывает ввод от источника до тех пор, пока не будет обнаружена тишина.

with mic as source:
    audio = r.listen(source)

Как только вы выполните блок with, попробуйте сказать «привет» в свой микрофон. Подождите, пока приглашение переводчика не отобразится снова. Как только будете готовы распознать речь добавьте:

print(r.recognize_google (аудио))   # 'Привет'

Если запрос не возвращается, ваш микрофон, скорее всего, воспринимает слишком много окружающего шума. Вы можете прервать процесс с помощью Ctrl+C, чтобы вернуть ваше приглашение.

Чтобы обрабатывать окружающий шум, вам нужно использовать метод adjust_for_ambient_noise() класса Recognizer, как вы это делали, когда пытались разобраться в шумном аудиофайле. Поскольку ввод с микрофона гораздо менее предсказуем, чем ввод из аудиофайла, рекомендуется делать это каждый раз, когда вы слушаете вход с микрофона.

with mic as source:
    r.adjust_for_ambient_noise(source)
    audio = r.listen(source)

После запуска приведенного выше кода, подождите секунду, пока метод adjust_for_ambient_noise() сделает свое дело, затем попробуйте сказать «привет» в микрофон. Опять же, вам придется немного подождать, пока переводчик предложит вернуться, прежде чем попытаться распознать речь.

adjust_for_ambient_noise() анализирует источник звука в течение одной секунды. Если это кажется вам слишком длинным, не стесняйтесь изменить его с помощью аргумента продолжительности ключевого слова.

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

Обработка неузнаваемой речи

Попробуйте набрать предыдущий пример кода и сделать несколько неразборчивых шумов в микрофон. Вы должны получить что-то вроде этого в ответ:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/david/real_python/speech_recognition_primer/venv/lib/python3.5/site-packages/speech_recognition/__init__.py", line 858, in recognize_google
    if not isinstance(actual_result, dict) or len(actual_result.get("alternative", [])) == 0: raise UnknownValueError()
speech_recognition.UnknownValueError

Аудио, которое не может быть сопоставлено с текстом API, вызывает исключение UnknownValueError. Вы должны всегда заключать вызовы API в блоки try и except, чтобы обработать это исключение.

Распознавание речи на языках, отличных от английского

Мы распознавали речь на английском языке, который является языком по умолчанию для каждого метода распознавания пакета SpeechRecognition. Тем не менее, это возможно для распознавания речи на других языках.

Чтобы распознавать речь на другом языке, задайте в качестве аргумента ключевого слова языка метода распознавания строку, соответствующую нужному языку. Большинство методов принимают языковой, например, «en-US» для американского английского или «fr-FR» для французского. Например, следующее распознает французскую речь в аудиофайле:

import speech_recognition as sr

r = sr.Recognizer()
with sr.AudioFile('path/to/audiofile.wav') as source:
    audio = r.record(source)

r.recognize_google(audio, language='fr-FR')

Только следующие методы принимают аргумент ключевого слова языка:

• recognize_bing ()
• recognize_google ()
• recognize_google_cloud ()
• recognize_ibm ()
• recognize_sphinx ()

Чтобы выяснить, какие языковые теги поддерживаются используемым API, вам нужно обратиться к соответствующей документации. В этом ответе о переполнении стека можно найти список тегов, принятых функцией accept_google().

Упражнения

В конце концов, вы примените то, что вы узнали, к простой игре «Угадай слово» и посмотрим, как все это объединится.

Распознавание речи, как следует из названия, относится к автоматическому распознаванию человеческой речи. Распознавание речи является одной из важнейших задач в области взаимодействия человека с компьютером. Если вы когда-либо общались с Alexa или когда-либо приказывали Сири выполнить задание, вы уже испытали силу распознавания речи.

Распознавание речи имеет различные приложения — от автоматической транскрипции речевых данных (например, голосовой почты) до взаимодействия с роботами посредством речи.

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

В Python было разработано несколько библиотек распознавания речи. Однако мы будем использовать библиотеку SpeechRecognition, которая является самой простой из всех библиотек.

Установка библиотеки SpeechRecognition

Выполните следующую команду для установки библиотеки:

pip install SpeechRecognition

Распознавание речи из аудио файлов

В этом разделе вы увидите, как мы можем переводить речь из аудиофайла в текст. Аудиофайл, который мы будем использовать в качестве входных данных, можно скачать по этой ссылке. Загрузите файл в вашу локальную файловую систему.

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

import speech_recognition as speech_recog

Для преобразования речи в текст нам нужен единственный класс — это класс Recognizer из модуля speech_recognition. В зависимости от базового API, используемого для преобразования речи в текст, класс Recognizer имеет следующие методы:

1. recognize_bing(): Использует Microsoft Bing Speech API
2. recognize_google(): Использует Google Speech API
3. recognize_google_cloud(): Использует Google Cloud Speech API
4. recognize_houndify(): Использует Houndify API от SoundHound
5. recognize_ibm(): Использует IBM Speech to Text API
6. recognize_sphinx(): Использует PocketSphinx API

Среди всех вышеперечисленных способов метод recognize_sphinx() можно использовать в автономном режиме для перевода речи в текст.

Чтобы распознать речь из аудиофайла, мы должны создать объект класса AudioFile модуля speech_recognition. Путь аудиофайла, который вы хотите перевести в текст, передается в конструктор класса AudioFile. Выполните следующий скрипт:

sample_audio = speech_recog.AudioFile('E:/Datasets/my_audio.wav')

В приведенном выше коде обновите путь к аудиофайлу, который вы хотите расшифровать.

Мы будем использовать метод recognize_google() для расшифровки наших аудио файлов. Тем не менее, метод recognize_google() требует объект AudioData модуля speech_recognition в качестве параметра. Чтобы преобразовать наш аудиофайл в объект AudioData, мы можем использовать метод record() класса Recognizer. Нам нужно передать объект AudioFile методу record(), как показано ниже:

with sample_audio as audio_file:
    audio_content = recog.record(audio_file)

Теперь, если вы проверите тип переменной audio_content, вы увидите, что она имеет тип speech_recognition.AudioData.

Результат:

speech_recognition.AudioData

Теперь мы можем просто передать объект audio_content методу recognize_google() объекта класса Recognizer(), и аудиофайл будет преобразован в текст. Выполните следующий скрипт:

recog.recognize_google(audio_content)

Результат:

'Bristol O2 left shoulder take the winding path to reach the lake no closely the size of the gas tank degrees office 30 face before you go out the race was badly strained and hung them the stray cat gave birth to kittens the young girl gave no clear response the meal was called before the bells ring what weather is in living'

Приведенный выше результат показывает текст аудиофайла. Вы можете видеть, что файл не был на 100% правильно транскрибирован, но точность довольно разумная.

Установка длительности и значений смещения

Вместо того, чтобы транскрибировать полную речь, вы также можете транскрибировать определенный сегмент аудиофайла. Например, если вы хотите транскрибировать только первые 10 секунд аудиофайла, вам нужно передать 10 в качестве значения параметра duration метода record(). Посмотрите на следующий скрипт:

sample_audio = speech_recog.AudioFile('E:/Datasets/my_audio.wav')
with sample_audio as audio_file:
    audio_content = recog.record(audio_file, duration=10)

recog.recognize_google(audio_content)

Результат:

'Bristol O2 left shoulder take the winding path to reach the lake no closely the size of the gas'

Таким же образом вы можете пропустить некоторую часть аудиофайла с самого начала, используя параметр offset. Например, если вы не хотите транскрибировать первые 4 секунды звука, передайте 4 в качестве значения для атрибута offset. Например, следующий скрипт пропускает первые 4 секунды аудиофайла, а затем транскрибирует аудиофайл в течение 10 секунд.

sample_audio = speech_recog.AudioFile('E:/Datasets/my_audio.wav')
with sample_audio as audio_file:
    audio_content = recog.record(audio_file, offset=4, duration=10)

recog.recognize_google(audio_content)

Результат:

'take the winding path to reach the lake no closely the size of the gas tank web degrees office dirty face'

Обработка шума

Аудио файл может содержать шум по разным причинам. Шум действительно может повлиять на качество перевода речи в текст. Чтобы уменьшить шум, класс Recognizer содержит метод adjust_for_ambient_noise(), который принимает объект AudioData в качестве параметра. Следующий скрипт показывает, как можно улучшить качество транскрипции, удалив шум из аудиофайла:

sample_audio = speech_recog.AudioFile('E:/Datasets/my_audio.wav')
with sample_audio as audio_file:
    recog.adjust_for_ambient_noise(audio_file)
    audio_content = recog.record(audio_file)

recog.recognize_google(audio_content)

Результат:

'Bristol O2 left shoulder take the winding path to reach the lake no closely the size of the gas tank web degrees office 30 face before you go out the race was badly strained and hung them the stray cat gave birth to kittens the younger again no clear response the mail was called before the bells ring what weather is in living'

Вывод очень похож на то, что мы получили ранее; это связано с тем, что в аудиофайле уже было очень мало шума.

Распознавание речи с живого микрофона

В этом разделе вы увидите, как вы можете транслировать живое аудио, полученное через микрофон в вашей системе.

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

Теперь источником транскрибируемого звука является микрофон. Чтобы захватить звук с микрофона, нам нужно сначала создать объект класса Microphone модуля Speach_Recogniton, как показано ниже:

mic = speech_recog.Microphone()

Чтобы увидеть список всех микрофонов в вашей системе, вы можете использовать метод list_microphone_names():

speech_recog.Microphone.list_microphone_names()

Результат:

['Microsoft Sound Mapper - Input',
 'Microphone (Realtek High Defini',
 'Microsoft Sound Mapper - Output',
 'Speakers (Realtek High Definiti',
 'Microphone Array (Realtek HD Audio Mic input)',
 'Speakers (Realtek HD Audio output)',
 'Stereo Mix (Realtek HD Audio Stereo input)']

Это список микрофонов, доступных в моей системе. Имейте в виду, что ваш список, скорее всего, будет выглядеть иначе.

Следующим шагом является захват звука с микрофона. Для этого вам нужно вызвать метод listen() класса Recognizer(). Как и метод record(), метод listen() также возвращает объект speech_recognition.AudioData, который затем может быть передан методу recognize_google().

Следующий скрипт предлагает пользователю что-то сказать в микрофон, а затем печатает все, что сказал пользователь:

with mic as audio_file:
    print("Speak Please")

    recog.adjust_for_ambient_noise(audio_file)
    audio = recog.listen(audio_file)

    print("Converting Speech to Text...")
    print("You said: " + recog.recognize_google(audio))

Как только вы выполните приведенный выше скрипт, вы увидите следующее сообщение:

В этот момент произнесите все, что хотите, и сделайте паузу. Как только вы сделали паузу, вы увидите транскрипцию всего, что вы сказали. Вот результат, который я получил:

Converting Speech to Text...
You said: hello this is normally from stack abuse abuse this is an article on speech recognition I hope you will like it and this is just a test speech and when I will stop speaking are you in today thank you for Reading

Важно отметить, что если метод recognize_google() не может сопоставить слова, которые вы говорите, с любым из слов в своем хранилище, выдается исключение. Вы можете проверить это, сказав несколько непонятных слов. Вы должны увидеть следующее исключение:

Speak Please
Converting Speech to Text...
---------------------------------------------------------------------------
UnknownValueError                         Traceback (most recent call last)
 in 
      8     print("Converting Speech to Text...")
      9
---> 10     print("You said: " + recog.recognize_google(audio))
     11
     12

~Anaconda3libsite-packagesspeech_recognition__init__.py in recognize_google(self, audio_data, key, language, show_all)
    856         # return results
    857         if show_all: return actual_result
--> 858         if not isinstance(actual_result, dict) or len(actual_result.get("alternative", [])) == 0: raise UnknownValueError()
    859
    860         if "confidence" in actual_result["alternative"]:

UnknownValueError:

Лучшим подходом является использование блока try при вызове метода recognize_google(), как показано ниже:

with mic as audio_file:
    print("Speak Please")

    recog.adjust_for_ambient_noise(audio_file)
    audio = recog.listen(audio_file)

    print("Converting Speech to Text...")

    try:
        print("You said: " + recog.recognize_google(audio))
    except Exception as e:
        print("Error: " + str(e))

Вывод

Распознавание речи имеет различные полезные приложения в области взаимодействия человека с компьютером и автоматической транскрипции речи. В этой статье кратко объясняется процесс транскрипции речи в Python через библиотеку speech_recognition и объясняется, как переводить речь в текст, когда источником звука является аудиофайл или живой микрофон.

microphone streaming with pyAudio