Python PyAudio Как обновить список микрофонов при повторном подключении
WIndows 10. Python. При работе с pyaudio выставляю индекс микрофона = 1. Гоняю цикл с микрофоном. При отключении внешнего микрофона от ноутбука перехватываю ошибку и продолжаю гонять цикл, в котором подхватывается все также микрофон с индексом = 1 (который теперь не внешний, а уже встроенный). Но данные в программе относительно информации о микрофоне обновить не могу. Вот так получаю список микрофонов:
def get_mics_list(): mics = [] p = pyaudio.PyAudio() for i in range(p.get_device_count()): if p.get_device_info_by_index(i)['name'] == 'Microsoft Sound Mapper - Input': pass elif p.get_device_info_by_index(i)['name'] == 'Microsoft Sound Mapper - Output': break else: mics.append(p.get_device_info_by_index(i)) return mics На выходе имею список словарей с информацией о каждом микрофоне в системе. Но при изменении микрофона в системе (например отключении микрофона), обновить информацию, используя эту функцию, не могу. Возвращает тот же список словарей, что и был до отключения микрофона. Почему так?
Как сделать диктофон на python
Инструкция по созданию приложения на python, с помощью которого можно записывать звук с микрофона, подключенного к компьютеру.
Создадим простой скрипт на python, с помощью которого можно записывать звук с микрофона, подключенного к компьютеру.
Я буду приводить пример для raspberry pi 3, но также это дело можно адаптировать для windows, проверял на ноутбуке с windows 7 с внутренним и usb микрофоном, записывает отлично.
Для начала нам нужно узнать, определился ли подключенный к системе микрофон.
Вlinux список подключенных устройств можно просмотреть командой:
Установка необходимых аудио-инструментов для Raspberry Pi
Мы будем использовать библиотеку Python ‘pyaudio’ для записи и воспроизведения аудиоданных с USB-микрофона.
Прежде чем мы сможем начать использовать ‘pyaudio,’ нам нужно убедиться, что RPi имеет все для необходимое для этого, установив следующие пакеты:
sudo apt install libportaudio0 libportaudio2 libportaudiocpp0 portaudio19-dev
Если все вышеперечисленное выполнено успешно, мы можем загрузить библиотеку ‘pyaudio’ (Я устанавливаю на Python 3.x с помощью команды ‘pip3’):
sudo pip3 install pyaudio
Если все вышеуказанное было сделано успешно, мы готовы перейти к следующему разделу и убедиться, что USB-микрофон работает, а Pi выбрал правильное устройство.
Тестирование USB микрофона и Pyaudio
Откройте в терминале Python 3.x и введите следующее:
>>> import pyaudio
>>> p = pyaudio.PyAudio()
>>> for i in range(p.get_device_count()):
>>> print(p.get_device_info_by_index(i).get(‘name’))
Это должно вывести индекс каждого аудиоустройства подключенного к вашему RPi.
Обратите внимание на индекс (номер) устройства USB, потому что нам нужно будет настроить индекс устройства pyaudio в соответствии с приведенной выше последовательностью. Например, our USB device index is “2” (index 0 is ALSA blank, index 1 is IEC958/HDMI, etc…).
ПРИМЕЧАНИЕ: ОБРАТИТЕ ВНИМАНИЕ НА ИНДЕКС (номер) USB-УСТРОЙСТВА, ПОТОМУ ЧТО НАМ НУЖНО будет указать его в PYAUDIO DEVICE.
НАПРИМЕР, МОЕ USB-УСТРОЙСТВО НАХОДИТСЯ ПО ИНДЕКСУ 2 (ИНДЕКС 0 IS ALSA MAIN, INDEX 1 IS IEC958/HDMI, ETC…).
Теперь, когда мы узнали под каким номером определился наш USB-микрофон, мы можем записать тестовый образец с помощью pyaudio. Подробную информацию об использовании pyaudio можно найти здесь.
import pyaudio
import wave
form_1 = pyaudio.paInt16 # 16-bit resolution
chans = 1 # 1 channel
samp_rate = 44100 # 44.1kHz sampling rate
chunk = 4096 # 2^12 samples for buffer
record_secs = 3 # seconds to record
dev_index = 2 # device index found by p.get_device_info_by_index(ii)
wav_output_filename = ‘test1.wav’ # name of .wav file
audio = pyaudio.PyAudio() # create pyaudio instantiation
# create pyaudio stream
stream = audio.open(format = form_1,rate = samp_rate,channels = chans, \
input_device_index = dev_index,input = True, \
frames_per_buffer=chunk)
print(«recording»)
frames = []
# loop through stream and append audio chunks to frame array
for ii in range(0,int((samp_rate/chunk)*record_secs)):
data = stream.read(chunk)
frames.append(data)
# stop the stream, close it, and terminate the pyaudio instantiation
stream.stop_stream()
stream.close()
audio.terminate()
# save the audio frames as .wav file
wavefile = wave.open(wav_output_filename,’wb’)
wavefile.setnchannels(chans)
wavefile.setsampwidth(audio.get_sample_size(form_1))
wavefile.setframerate(samp_rate)
wavefile.writeframes(b».join(frames))
wavefile.close()
Выходной файл .wav должен иметь длину 3 секунды (при условии, что приведенный выше код не изменился) и дискретизируется с частотой 44,1 кГц с максимальным разрешением 16 бит. В зависимости от используемого микрофона частоту дискретизации можно увеличить до 48 кГц. Битовую глубину также можно изменить, хотя я не совсем уверен в ограничениях возможностей Pi.
Что делает функция индекс в Python?
Метод index() в Python помогает найти значение индекса элемента в последовательности. Он выдает наименьший возможный индекс указанного элемента. Если указанный элемент не существует, то возвращается ValueError.
sequence.index(x[, start[, end]]) - sequence — это объект, элементы которого представляют собой некую индексированную последовательность (строка, список, кортеж). Каждый элемент последовательности имеет индекс — целое число, обозначающее его позицию в последовательности. Нумерация индексов начинается с 0 (нуля).
- x — искомый элемент последовательности, чей наименьший индекс будет возвращен.
- Необязательные аргументы start и end используются для ограничения поиска конкретной подпоследовательностью списка, путем задания среза. Возвращаемый индекс вычисляется относительно изначальной последовательности, а не среза, заданного start и end.
str_seq = 'aebcdef' #Последовательность в виде строки print(str_seq.index('e')) # => 1 print(str_seq.index('e', 2)) # => 5 print(str_seq.index('k')) # => ValueError: substring not found lst_seq = ['a', 'e', 'b', 'c', 'd', 'e', 'f'] #Последовательность в виде списка print(lst_seq.index('b')) # => 2 print(lst_seq.index('k')) # => ValueError: 'k' is not in list tup_seq = ('a', 'e', 'b', 'c', 'd', 'e', 'f') #Последовательность в виде кортежа print(tup_seq.index('a')) # => 0 Распознавание речи и голоса на Python – подробно
Вы когда-нибудь задумывались о том, как Google Assistant или Amazon Alexa распознает все, что вы говорите? Помимо огромного успеха на рынке систем распознавания, большая часть сотовых устройств имеет функцию распознавания речи через некоторые встроенные приложения или сторонние приложения.
Не обязательно, но большинство таких систем распознавания речи построено и развернуто с помощью пакетов и библиотек python. В определенной степени Python доказал, что это важный аспект обозримого будущего. Причина довольно очевидна. Чтобы включить распознавание речи в Python, вам потребуется определенный уровень интерактивности и доступности, соответствующий технологиям.
Концепция доступности заслуживает рассмотрения, потому что распознавание позволяет пожилым людям, людям с ограниченными физическими возможностями или слабовидящим людям взаимодействовать с машинами и быстро решать свои проблемы с помощью современных услуг и продуктов, не выбирая случайные приложения с графическим интерфейсом пользователя.
В этой статье мы научимся создавать систему распознавания речи и голоса на Python. Чтобы облегчить процесс понимания того, как она устроена, эта статья призвана научить вас, как построить систему с меньшими усилиями и с большим энтузиазмом. Но прежде чем перейти к проекту, давайте поговорим о некоторых не менее важных аспектах, которые нужно знать разработчику.
Как работает распознавания речи?
Прежде чем переходить к деталям и сложностям проекта, вы должны составить и понять краткий обзор работы распознавания речи. Хотя для начала работы нет никаких предварительных условий, все же хорошо владеть основами языка программирования Python.
Распознавание речи возникло в результате исследований, проведенных Bell Labs еще в 1950 году, с ограничениями только для одного говорящего и с ограниченной базой словарного запаса. Современные приложения для распознавания речи прошли долгий путь с момента появления древних аналогов.
Говоря о составляющих, первая из них – это речь. Она должна быть преобразована из звука в сигнал, который может проходить через микрофон и может быть преобразована в цифровые данные. Это делается с помощью аналого-цифрового преобразователя. После того, как данные оцифрованы, несколько моделей могут легко преобразовать звук в текст.
Современные распознаватели речи основаны на менее известной концепции Hidden Markov Model (HMM). Подход основан на предположениях, сформулированных для речевого сигнала, когда он сохраняется в течение короткого периода (скажем, пять миллисекунд), и его можно назвать стационарным процессом, то есть процессом, основанным на статистике, которая не меняется с течением времени.
В типичном HMM разделение речи по умолчанию на сигнал составляет около десяти миллисекунд, разделенных на различные фрагменты. Спектр мощности каждого фрагмента помогает сигналам построить функцию и сгенерировать частоту, которая позже отображается на вектор действительных чисел, называемый кепстральным коэффициентом.
Размеры отображаемого вектора довольно малы, всего 10, по сравнению с некоторыми точными системами, которые могут иметь размеры, достигающие 32 или более. Сгенерированный окончательный результат HMM принимает форму векторных последовательностей.
Группа векторов играет важную роль в декодировании речи в текст с помощью фонем, которые являются основными единицами речи. Вычисление фонем зависит от обучения, так как говорящие различаются, и даже у одного и того же говорящего иногда бывает разное произношение. Поэтому, чтобы справиться с этой проблемой, рассматривается специальный алгоритм, определяющий наиболее относительные слова, образующие последовательность фонем.
Весь процесс, который вы только что изучили, довольно дорог с точки зрения вычислений. Нейронные сети используются для преобразования функций и размеров в современных системах распознавания речи, снижая потребность в HMM.
Кроме того, детекторы голосовой активности (VAD) также используются для уменьшения некоторой части аудиосигнала, которая может содержать речь. В основном он используется для распознавания неважных частей речи и предотвращения их принятия во внимание.
Пакеты распознавания речи
В цепочке PyPI существует несколько пакетов для распознавания речи. Вот некоторые из них:
- Assembly
- Apia
- SpeechRecognition
- Wit
- 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, указаны ниже:
- WAV: формат должен быть в PCM / LPCM
- AIFF
- AIFF-C
- 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) , , , , , ], '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, являющийся широко используемым языком программирования и сценариев, охватывает большинство приложений распознавания речи с помощью его внешних библиотек и фреймворков, которые демонстрируют его способность справляться с критическими проблемами с помощью всего нескольких строк простого и читаемого кода.