Почему я отказался от облачных ASR и собрал инструмент для распознавания речи сам

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

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

Из этой статьи вы узнаете, как самостоятельно сделать автоматические системы распознавания речи ASR (Automatic Speech Recognition) с применением современных нейросетей и программ на Python. Эти системы смогут выделять спикеров при обработке звуковых файлов, а также распознавать речь в потоке, поступающую, например, от микрофона или радиоприёмника.

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

Устройство человеческого уха

Человек очень легко разбирает речь, улавливая смысл сказанного. Но как он это делает?

Чтобы понять успех современных технологий распознавания речи, расскажу кратко об устройстве человеческого уха (рис. 1).

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

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

Человеческое ухо работает, подобно обычным микрофонам. Разумеется, устройство, физические принципы действия и сигналы на «выходе» человеческого уха не такие, как у обычных микрофонов.

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

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

Тем из вас, кто знаком с нейросетями, сразу будет видна аналогия. 

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

На уровне слуховой коры мозга признаки объединяются во времени, учитывается контекст и выполняется предсказание. Это похоже на работу рекуррентных сетей, трансформеров и attention-механизмов, где текущая интерпретация сигналов зависит от предыдущих состояний с учётом наиболее вероятного смысла.

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

Как распознавали речь до появления нейросетей

Первые попытки распознавания речи предпринимались еще в 1950-1960 годы. Тогда удавалось распознавать только отдельные цифры путём сравнения аудиосигнала с заранее заданными шаблонами. 

Далее в 1970-1980 годах стали применять статистические методы. Использовались алгоритмы для выравнивания звуковых последовательностей разной длины, чтобы можно было сравнивать слова с учётом скорости произношения. Но эти методы работали только для небольших словарей, при этом успех распознавания зависел от диктора.

С 1980 до 1990 года также применяли статистические методы с использованием сочетания скрытых Марковских моделей с моделя��и Гауссовых смесей. Были даже попытки создания систем непрерывного распознавания речи, таких как CMU Sphinx. Но эти модели требовали сложного ручного выделения признаков и больших фонетических словарей.

Сегодня успешного распознавания речи, в том числе непрерывного, удаётся добиться с помощью глубоких сетей DNN, RNN/LSTM и трансформеров. Нейросети резко улучшили качество распознавания, повысили точность и устойчивость к шуму. Это позволило применять технологию распознавания в промышленных масштабах, в домашних системах и даже в смартфонах.

Подробнее об истории распознавания речи можно прочитать в статье «Распознавание речи: очень краткий вводный курс». Также возможно вам будет интересна статья «Динамическое программирование в алгоритмах распознавания речи».

Нужен ли свой сервис распознавания речи

Зачем создавать собственную систему распознавания речи, когда на рынке есть немало готовых коммерческих сервисов?

Безопасность и независимость

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

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

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

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

Экономия при больших объёмах обработки

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

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

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

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

Настройка на свои задачи

На своей системе вы сможете настраивать модели и алгоритмы обработки исходя из ваших уникальных нужд. 

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

Работа без интернета

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

Переходим к практике

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

Сначала я расскажу, как такое распознавание можно сделать в среде ОС Microsoft Windows на обычном настольном компьютере, оборудованном видеокартой с GPU, а таже на ноутбуке. Затем я рассмотрю более профессиональное решение с применением серверов с GPU, позволяющее не только распознавать речь в файлах, но и выполнять так называемую диаризацию — выделение потоков речи отдельных спикеров.

Отдельно расскажу про возможность распознавания речи в звуковом сигнале от микрофона в реальном времени.

Проверим наличие и тип GPU

В ОС Microsoft Windows проще всего проверить наличие, тип и параметры GPU с помощью диспетчера задач. Откройте вкладку Производительность и перейдите в раздел GPU или Графический процессор (рис. 2).

В правом верхнем углу вы можете увидеть тип GPU (у меня это NVIDIA GeForce GTX 1650). У этого GPU на борту 4 ГБайта памяти. Кроме этого, здесь можно узнать объём видеопамяти и посмотреть, сколько памяти GPU занято.

Тип GPU, выпущенного NVIDIA, также можно узнать из командной строки:

c:>nvidia-smi --query-gpu=name,memory.total,compute_cap --format=csv
name, memory.total [MiB], compute_cap
NVIDIA GeForce GTX 1650, 4096 MiB, 7.5

Для распознавания речи на Windows я использовал порт модели Whisper.cpp от OpenAI, и он может работать с таким GPU.

На другом компьютере (ноутбуке) у меня установлен GPU типа Intel Iris Xe Graphics, который, к сожалению, не поддерживается Whisper.cpp. Там распознавание речи через Whisper.cpp будет работать только на CPU (либо нужно использовать другие модели и ПО распознавания).

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

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

• Whisper –— продукт, созданный OpenAI;

• Whisper.cpp — реализация Whisper для CPU и GPU на C/C++;

• Faster-Whisper — оптимизированная реализация Whisper;

• Parakeet v3 — модель автоматического распознавания речи от NVIDIA, способная работать в режиме реального времени. Модель parakeet-tdt-0.6b-v3 распространяется под лицензией CC-BY-4.0 (Creative Commons Attribution 4.0 International), разрешающей коммерческое и некоммерческое использование с указанием авторства

Заслуживают упоминания и другие модели, которые остались за бортом этой статьи, например:

• Vosk — может работать не только на компьютерах, но и на микрокомпьютерах, таких как Raspberry Pi;

• GigaAM-v3 — модель, оптимизированная для русского языка, в некоторых случаях работает лучше Whisper;

• T-one — модель для потокового распознавания речи на русском языке

Сравнение этих и других моделей можно найти в статье «Открытые модели для распознавания русской речи 2025».

Запуск распознавания на CPU

Для начала установим ПО Whisper.cpp, собранное для распознавания речи на CPU. Для этого перейдите на страницу https://github.com/ggml-org/whisper.cpp/releases. Загрузите файл whisper-bin-x64.zip и распакуйте архив в каталог c:/whisper. Убедитесь, что в этом каталоге появился файл whisper-cli.exe.

Далее скачайте модели с этой страницы. Подойдёт модель ggml-large-v3.bin, но есть и модели меньшего размера ggml-medium.bin и ggml-small.bin. Файлы моделей запишите в каталог c:whispermodels.

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

Теперь вам понадобится звуковой файл с речью. Для Whisper.cpp лучше всего использовать монофонический wav-файл с кодеком PCM 16 бит и частотой дискретизации 16000 Гц. Вы можете записать такой файл с микрофона, например, при помощи программы Ocenaudio (рис. 3).

Ниже показаны результаты распознавания речи из небольшого файла, записанного в этой программе с микрофона:

cd C:whisper
C:whisper>whisper-cli.exe -m modelsggml-large-v3.bin -f c:asr-fvdsinputfrom-mic.wav -l ru

whisper_init_from_file_with_params_no_state: loading model from 'modelsggml-large-v3.bin'
whisper_init_with_params_no_state: use gpu    = 1
whisper_init_with_params_no_state: flash attn = 1
whisper_init_with_params_no_state: gpu_device = 0
whisper_init_with_params_no_state: dtw        = 0
whisper_init_with_params_no_state: devices    = 1
whisper_init_with_params_no_state: backends   = 1
whisper_model_load: loading model
whisper_model_load: n_vocab       = 51866
whisper_model_load: n_audio_ctx   = 1500
whisper_model_load: n_audio_state = 1280
whisper_model_load: n_audio_head  = 20
whisper_model_load: n_audio_layer = 32
whisper_model_load: n_text_ctx    = 448
whisper_model_load: n_text_state  = 1280
whisper_model_load: n_text_head   = 20
whisper_model_load: n_text_layer  = 32
whisper_model_load: n_mels        = 128
whisper_model_load: ftype         = 1
whisper_model_load: qntvr         = 0
whisper_model_load: type          = 5 (large v3)
whisper_model_load: adding 1609 extra tokens
whisper_model_load: n_langs       = 100
whisper_model_load:          CPU total size =  3094.36 MB
whisper_model_load: model size    = 3094.36 MB
whisper_backend_init_gpu: no GPU found
whisper_init_state: kv self size  =   83.89 MB
whisper_init_state: kv cross size =  251.66 MB
whisper_init_state: kv pad  size  =    7.86 MB
whisper_init_state: compute buffer (conv)   =   36.15 MB
whisper_init_state: compute buffer (encode) =   55.35 MB
whisper_init_state: compute buffer (cross)  =    9.27 MB
whisper_init_state: compute buffer (decode) =   99.12 MB
system_info: n_threads = 4 / 24 | WHISPER : COREML = 0 | OPENVINO = 0 | CPU : SSE3 = 1 | SSSE3 = 1 | AVX = 1 | AVX2 = 1 | F16C = 1 | FMA = 1 | OPENMP = 1 | REPACK = 1 |

main: processing 'c:asr-fvdsinputfrom-mic.wav' (259662 samples, 16.2 sec), 4 threads, 1 processors, 5 beams + best of 5, lang = ru, task = transcribe, timestamps = 1 ...

[00:00:00.000 --> 00:00:02.680]   Раз, два, три, четыре, пять.
[00:00:02.680 --> 00:00:04.320]   Вышел зайчик погулять.
[00:00:04.320 --> 00:00:06.340]   Вдруг охотник выбегает.
[00:00:06.340 --> 00:00:07.940]   Прямо в зайчика стреляет.
[00:00:07.940 --> 00:00:10.940]   Пиф-паф, ой-ой-ой, умирает зайчик мой.
[00:00:10.940 --> 00:00:12.840]   Принесли его домой.
[00:00:12.840 --> 00:00:14.420]   Оказался он живой.

whisper_print_timings:     load time =  2253.82 ms
whisper_print_timings:     fallbacks =   0 p /   0 h
whisper_print_timings:      mel time =    10.15 ms
whisper_print_timings:   sample time =   220.31 ms /   450 runs (     0.49 ms per run)
whisper_print_timings:   encode time = 19060.17 ms /     1 runs ( 19060.17 ms per run)
whisper_print_timings:   decode time =     0.00 ms /     1 runs (     0.00 ms per run)
whisper_print_timings:   batchd time = 10459.48 ms /   448 runs (    23.35 ms per run)
whisper_print_timings:   prompt time =     0.00 ms /     1 runs (     0.00 ms per run)
whisper_print_timings:    total time = 32169.96 ms

Качество распознавания — идеальное. Программа попыталась включить GPU (use gpu = 1), но в итоге GPU не найден, а для распознавания использовался CPU. Дело в том, что сначала я установил версию Whisper.cpp без поддержки GPU.

Общее время распознавания составило 32 секунды.

Запустим распознавание на wav-файле размером примерно 3 МБайт, полученного при записи передачи FM-станции.

cd C:whisper
C:whisper>whisper-cli.exe -m modelsggml-large-v3.bin -f 
c:asr-fvdsinputinput.wav -l ru

Приведу сокращённую выдачу команды:

whisper_init_from_file_with_params_no_state: loading model from 'modelsggml-large-v3.bin'
whisper_init_with_params_no_state: use gpu    = 1
whisper_init_with_params_no_state: flash attn = 1
…
main: processing 'c:asr-fvdsinputinput.wav' (1694870 samples, 105.9 sec), 4 threads, 1 processors, 5 beams + best of 5, lang = ru, task = transcribe, timestamps = 1 ...


[00:00:00.000 --> 00:00:01.820]   Ольга, как вы стали поэтом?
[00:00:01.820 --> 00:00:04.300]   Вы всё-таки мне конкретно не ответили.
[00:00:04.300 --> 00:00:05.660]   Могу, могу.
[00:00:05.660 --> 00:00:06.880]   Мы так увлек...
[00:00:06.880 --> 00:00:09.980]   Знаете, замечательно, когда можно говорить с человеком,
[00:00:09.980 --> 00:00:11.600]   с которым завихришься,
[00:00:11.600 --> 00:00:13.760]   и даже если не ответил на вопрос,
[00:00:13.760 --> 00:00:15.740]   а всё равно что-нибудь приятное
[00:00:15.740 --> 00:00:17.320]   и сказал, и вспомнил, и почувствовал.
[00:00:17.320 --> 00:00:19.340]   Спасибо. Нет, это правда.
[00:00:19.340 --> 00:00:21.780]   Для меня поговорить с человеком,
[00:00:21.780 --> 00:00:23.640]   с которым вот этот разговор был
[00:00:23.640 --> 00:00:26.180]   и содержателен, и эмоционален,
[00:00:26.180 --> 00:00:27.840]   и приятен, и грел изнутри,
[00:00:28.280 --> 00:00:30.680]   знаете, это вот удовольствие побольше многих.
[00:00:30.680 --> 00:00:32.500]   Скажу честно, что
[00:00:32.500 --> 00:00:34.680]   вот на фоне всего того, что я пробовала
[00:00:34.680 --> 00:00:36.540]   писать, ну, в школе там
[00:00:36.540 --> 00:00:38.700]   это совсем такое, ну, капустник
[00:00:38.700 --> 00:00:40.720]   на выпускной, на последний, у нас традиция
[00:00:40.720 --> 00:00:42.720]   была в этой самой школе, которую я заканчивала,
[00:00:42.720 --> 00:00:44.300]   выпускные классы
[00:00:44.300 --> 00:00:46.760]   закатывали большой-большой капустный, часа на два.
[00:00:46.760 --> 00:00:48.880]   Ну, а потом это всё писалось
[00:00:48.880 --> 00:00:50.820]   просто в стол для души, как отдушина.
[00:00:50.820 --> 00:00:52.000]   Особенно, повторюсь,
[00:00:52.000 --> 00:00:54.840]   вот уже когда стало понятно,
[00:00:54.840 --> 00:00:56.840]   что сначала ничего не понятно, а потом всё рухнуло.
[00:00:58.280 --> 00:01:00.000]   И, может быть, я не набралась бы
[00:01:00.000 --> 00:01:01.860]   оковянства вообще как-то это выносить
[00:01:01.860 --> 00:01:04.100]   на публику, если бы
[00:01:04.100 --> 00:01:05.860]   не познакомилась с Алексеем Дедуровым.
[00:01:05.860 --> 00:01:06.940]   Вот так.
[00:01:06.940 --> 00:01:09.320]   Да. Дело в том, что в редакции
[00:01:09.320 --> 00:01:11.420]   многотиражной газеты
[00:01:11.420 --> 00:01:14.040]   МВТУ имени Баумана, где я была тогда редактором...
[00:01:14.040 --> 00:01:15.740]   Угу. То есть у нас с вами ещё одна
[00:01:15.740 --> 00:01:17.100]   пуповинка образовывается.
[00:01:17.100 --> 00:01:20.020]   Да. Дело в том, что я бауманец по первому образованию.
[00:01:20.020 --> 00:01:21.820]   Вот. И с которой мы
[00:01:21.820 --> 00:01:23.420]   выиграли последний в истории
[00:01:23.420 --> 00:01:25.580]   Министерства образования СССР
[00:01:25.580 --> 00:01:28.080]   всесоюзный конкурс студенческих газет.
[00:01:28.280 --> 00:01:29.780]   Мы первое место тогда заняли.
[00:01:29.780 --> 00:01:31.460]   И вот, например, поэма
[00:01:31.460 --> 00:01:33.340]   «Ворошиловский стрелок Дедурова» впервые была
[00:01:33.340 --> 00:01:35.660]   публикована у Бауманца. Благодаря чему?
[00:01:35.660 --> 00:01:37.480]   Потому что в редакции работала Ленка Исаева.
[00:01:37.480 --> 00:01:39.980]   Вот. Это она ещё не была
[00:01:39.980 --> 00:01:41.580]   тогда не членом Союза писателей,
[00:01:41.580 --> 00:01:42.980]   а была моим корреспондентом.
[00:01:42.980 --> 00:01:45.120]   Я была редактором в свои 25 лет.

whisper_print_timings:     load time =  2266.38 ms
whisper_print_timings:     fallbacks =   0 p /   0 h
whisper_print_timings:      mel time =    55.18 ms
whisper_print_timings:   sample time =  1555.62 ms /  3324 runs (     0.47 ms per run)
whisper_print_timings:   encode time = 76276.59 ms /     4 runs ( 19069.15 ms per run)
whisper_print_timings:   decode time =   175.39 ms /     2 runs (    87.70 ms per run)
whisper_print_timings:   batchd time = 83947.35 ms /  3305 runs (    25.40 ms per run)
whisper_print_timings:   prompt time =  8592.33 ms /   623 runs (    13.79 ms per run)
whisper_print_timings:    total time = 173158.34 ms

Как видите, распознавание на CPU было выполнено за 173 секунды и довольно качественно.

Ускорим распознавание с помощью GPU

Для использования GPU на компьютере с Microsoft Windows и видеокартой NVIDIA скачайте архив whisper-cublas-12.4.0-bin-x64.zip, распаковав его в каталог C:whisper-cuda. Затем скопируйте модели в каталог C:whisper-cudamodels.

Запустим распознавание сначала для небольшого файла from-mic.wav:

cd C:whisper-cuda
C:whisper-cuda>whisper-cli.exe -m modelsggml-large-v3.bin -f c:asr-fvdsinputfrom-mic.wav -l ru
ggml_cuda_init: GGML_CUDA_FORCE_MMQ:    no
ggml_cuda_init: GGML_CUDA_FORCE_CUBLAS: no
ggml_cuda_init: found 1 CUDA devices:
  Device 0: NVIDIA GeForce GTX 1650, compute capability 7.5, VMM: yes
whisper_init_from_file_with_params_no_state: loading model from 'modelsggml-large-v3.bin'
whisper_init_with_params_no_state: use gpu    = 1
whisper_init_with_params_no_state: flash attn = 1
whisper_init_with_params_no_state: gpu_device = 0
whisper_init_with_params_no_state: dtw        = 0
whisper_init_with_params_no_state: devices    = 2
whisper_init_with_params_no_state: backends   = 2
whisper_model_load: loading model
…
whisper_model_load: CUDA0 total size =  3094.36 MB
whisper_model_load: model size    = 3094.36 MB
whisper_backend_init_gpu: using CUDA0 backend
…

main: processing 'c:asr-fvdsinputfrom-mic.wav' (259662 samples, 16.2 sec), 4 threads, 1 processors, 5 beams + best of 5, lang = ru, task = transcribe, timestamps = 1 ...

[00:00:00.000 --> 00:00:02.680]   Раз, два, три, четыре, пять.
[00:00:02.680 --> 00:00:04.320]   Вышел зайчик погулять.
[00:00:04.320 --> 00:00:06.340]   Вдруг охотник выбегает.
[00:00:06.340 --> 00:00:07.940]   Прямо в зайчика стреляет.
[00:00:07.940 --> 00:00:10.940]   Пиф-паф, ой-ой-ой, умирает зайчик мой.
[00:00:10.940 --> 00:00:12.840]   Принесли его домой.
[00:00:12.840 --> 00:00:14.420]   Оказался он живой.

whisper_print_timings:     load time =  2965.71 ms
whisper_print_timings:     fallbacks =   0 p /   0 h
whisper_print_timings:      mel time =     9.60 ms
whisper_print_timings:   sample time =   146.28 ms /   450 runs (     0.33 ms per run)
whisper_print_timings:   encode time =  7960.13 ms /     1 runs (  7960.13 ms per run)
whisper_print_timings:   decode time =     0.00 ms /     1 runs (     0.00 ms per run)
whisper_print_timings:   batchd time = 12136.23 ms /   448 runs (    27.09 ms per run)
whisper_print_timings:   prompt time =     0.00 ms /     1 runs (     0.00 ms per run)
whisper_print_timings:    total time = 23438.64 ms

Как видите, на этот раз был использован GPU:

ggml_cuda_init: found 1 CUDA devices:
  Device 0: NVIDIA GeForce GTX 1650, compute capability 7.5, VMM: yes
whisper_init_from_file_with_params_no_state: loading model from 'modelsggml-large-v3.bin'

С GPU время распознавания составило 23 секунды, против 32 секунд работы только на CPU.

Теперь запустим распознавание на большом файле:

cd C:whisper-cuda
whisper-cli.exe -m modelsggml-large-v3.bin -f 
c:asr-fvdsinputinput.wav -l ru

Посмотрим на выдачу команды:

whisper_print_timings:     load time =  2899.25 ms
whisper_print_timings:     fallbacks =   0 p /   0 h
whisper_print_timings:      mel time =    54.38 ms
whisper_print_timings:   sample time =  1232.07 ms /  3331 runs (     0.37 ms per run)
whisper_print_timings:   encode time = 30350.93 ms /     4 runs (  7587.73 ms per run)
whisper_print_timings:   decode time =   656.79 ms /    11 runs (    59.71 ms per run)
whisper_print_timings:   batchd time = 90675.35 ms /  3303 runs (    27.45 ms per run)
whisper_print_timings:   prompt time =  4313.50 ms /   623 runs (     6.92 ms per run)
whisper_print_timings:    total time = 130534.67 ms

Как видите, время распознавания с применением GPU составило 130 секунд, по сравнению с 173 секундами на CPU.

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

whisper-cli.exe -m modelsggml-large-v3.bin -f 
c:asr-fvdsinputinput.wav -l ru -t 12 -otxt -nt -pc false

Здесь мы использовали 12 потоков CPU (параметр -t 12), выводим только текст (-otxt), отменили вывод временных меток слов (-nt), отключили вывод прогресса в консоль (-pc false). 

Теперь вместо 130 секунд программа всё сделала за 116 секунд:

whisper_print_timings:     load time =  2794.66 ms
whisper_print_timings:     fallbacks =   0 p /   0 h
whisper_print_timings:      mel time =    33.83 ms
whisper_print_timings:   sample time =  1024.46 ms /  2801 runs (     0.37 ms per run)
whisper_print_timings:   encode time = 29749.33 ms /     4 runs (  7437.33 ms per run)
whisper_print_timings:   decode time =   194.69 ms /     3 runs (    64.90 ms per run)
whisper_print_timings:   batchd time = 77307.71 ms /  2782 runs (    27.79 ms per run)
whisper_print_timings:   prompt time =  4352.52 ms /   600 runs (     7.25 ms per run)
whisper_print_timings:    total time = 115867.71 ms

Загрузку GPU можно наблюдать в диспетчере задач (рис. 4).

GPU в Microsoft Windows 11 используется для ускорения и при обычной работе, например, при открытии или перемещении окон. Распознавание речи отнимает практически все ресурсы GPU.

Распознавание речи в файлах с выделением спикеров

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

Я сделал такую систему на сервере Ubuntu 22.04 с GPU Tesla-T4 на базе Whisper — модели распознавания речи от OpenAI, CUDA, Python и сервера WebSocket.

Установка ПО на сервер

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

При установке прежде всего нужно обновить и перезагрузить систему:

$ sudo apt update && sudo apt upgrade -y
$ sudo reboot

На следующем шаге устанавливаем драйверы NVIDIA:

$ mkdir asr-public
$ cd asr-public
$ chmod +x install_nvidia_definite_public.sh
./install_nvidia_definite_public.sh

Скрипт install_nvidia_definite_public.sh вы можете загрузить из моего репозитория.

После установки перезагрузите OC и запустите программу nvidia-smi (рис. 5).

Здесь вы увидите тип GPU, установленного на сервере, версию драйвера и CUDA, объем памяти GPU (в данном случае 16 ГБайт) и другую информацию.

На следующем этапе запустите скрипт полной установки необходимых модулей Python install_complete-public.sh:

$ chmod +x install_complete-public.sh
$ ./install_complete-public.sh

При успешном завершении он выведет на консоль версии установленных программ и пакетов:

Все компоненты установлены:
  • PyTorch 2.1.0 + CUDA 11.8
  • PyTorch Lightning 2.0.9
  • Whisper (все модели)
  • PyAnnote 3.1.1

Если всё хорошо, проверьте систему скриптом check_system-public.sh:

chmod +x check_system-public.sh
./check_system-public.sh

Этот скрипт должен показать на консоли краткий отчёт:

=========================================
КРАТКИЙ ОТЧЕТ
=========================================
ОС: Ubuntu 22.04.5 LTS
Python: 3.10.12
GPU: Обнаружена (Tesla T4)
Отсутствует пакетов: 15 системных, 11 Python
=========================================

Теперь активируйте виртуальное окружение Python, чтобы продолжить в нём установку:

$ source whisper_gpu_complete_env/bin/activate
(whisper_gpu_complete_env) ubuntu@asr01:~$

Запустите в этом окружении скрипт quick_test.sh (будет создан автоматически скриптом install_complete-public.sh), а затем программу whisper с параметром -h для выдачи справки об использовании:

./quick_test.sh
whisper -h

Запуск программы распознавания с диаризацией

После установки первым делом выполните быструю проверку распознавания, загрузив звуковой файл с речью на английском языке из репозитория Github и запустите whisper:

$ wget -q https://github.com/openai/whisper/raw/main/tests/jfk.flac
$ whisper jfk.flac --model tiny --device cuda --output_format txt

Если все работает, испытайте более сложную программу с диаризацией whisper_pyannote_gpu_v3.py, загрузив её из моего репозитория:

$ source whisper_gpu_complete_env/bin/activate

$ python whisper_pyannote_gpu_v3.py 
/home/ubuntu/asr-public/input/fm-records_25.wav --whisper-model 
large-v3 --language ru --export-all --hf-token hf_*********

В параметре –hf-token нужно задать токен, полученный на сайте https://huggingface.co. Это можно сделать бесплатно, но потребуется регистрация.

После завершения распознавания на консоли появятся результаты, показанные здесь в сокращённом виде:

======================================================================
ДИАРИЗАЦИЯ И ТРАНСКРИПЦИЯ (v2.1)
======================================================================
Устройство: cuda
Аудиофайл: /home/ubuntu/asr-public/input/fm-records_25.wav
Диаризация: включена
Сценарий: meeting
Модель Whisper: large-v3

Этап 1: Конфигурация...
Этап 2: Диаризация...
Загрузка модели диаризации для сценария 'meeting'...
Применение гиперпараметров: ['min_speakers', 'max_speakers', 'segmentation_threshold', 'clustering', 'step']
Модель загружена на cuda
Диаризация файла: fm-records_25.wav
Дополнительные параметры: {'min_speakers': 2, 'max_speakers': 10}
✓ Обнаружено 114 сегментов диаризации
✓ Обнаружено 2 спикеров: SPEAKER_00, SPEAKER_01

Этап 3: Транскрипция...
Загрузка модели Whisper large-v3 на cuda...
Транскрипция файла: fm-records_25.wav
Запуск распознавания...
✓ Распознано 117 сегментов транскрипции

Этап 4: Совмещение и постобработка...
Совмещение транскрипции и диаризации...
  Совмещено 20/117 сегментов
  Совмещено 40/117 сегментов
  Совмещено 60/117 сегментов
  Совмещено 80/117 сегментов
  Совмещено 100/117 сегментов
  Совмещено 117/117 сегментов
✓ Совмещение завершено
Постобработка сегментов...
✓ После постобработки: 9 сегментов, 2 спикеров

Этап 5: Экспорт результатов...
Экспорт в текстовый файл: ./results/fm-records_25_20260118_094116.txt
Экспорт в JSON: ./results/fm-records_25_20260118_094116.json
Экспорт в SRT: ./results/fm-records_25_20260118_094116.srt
Экспорт в VTT: ./results/fm-records_25_20260118_094116.vtt
Статистика сохранена: ./results/fm-records_25_20260118_094116_stats.json

======================================================================
ОБРАБОТКА ЗАВЕРШЕНА
======================================================================
✓ Файл результатов: ./results/fm-records_25_20260118_094116.txt
✓ Общее время аудио: 414.8 сек (6.9 мин)
✓ Всего сегментов: 9
✓ Обнаружено спикеров: 2

Распределение по спикерам:
  SPEAKER_01: 375.6 сек (90.5%)
  SPEAKER_02: 31.1 сек (7.5%)
✓ Результаты сохранены в: ./results

После завершения работы программа запишет результаты в файлы типов JSON, SRT, и VTT (рис. 5). Также в формате JSON будет сохранена статистика.

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

Краткое описание программы whisper_pyannote_gpu_v3

Программа whisper_pyannote_gpu_v3.py объединяет распознавание речи (на базе Whisper) и диаризацию спикеров (через PyAnnote Speaker Diarization 3.1). Обе эти функции используют для ускорения работы GPU.

Для распознавания речи модуль AdvancedWhisperTranscriber загружает модель Whisper. Если на сервере есть GPU, используется оптимизация.

Модуль AdvancedDiarizer создаёт список сегментов по времени с идентификаторами спикеров и статистикой. Он реализует алгоритм автоматического определения речи VAD (Voice Activity Detection), выделяя ее из тишины и шума.

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

Здесь оценка уверенности — это числовая мера того, насколько модель “уверена”, что данный фрагмент речи принадлежит конкретному спикеру.

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

Оптимизация аудио файлов

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

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

Чтобы улучшить звуковой файл с речью, можно обработать его, например, программой ffmpeg.

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

ffmpeg -i /home/ubuntu/input/23-sent-20.45​.aac_000.aac -af "highpass=f=150, lowpass=f=7500, equalizer=f=180:t=q:w=1:g=-6, afftdn=nf=-28, dynaudnorm=f=200:g=18" -ar 16000 -ac 1 -c:a pcm_s16le /home/ubuntu/input/whisper.wav

Здесь параметры аудио фильтров -af решают такие задачи:

• highpass=f=150 — убирает низкочастотный гул и вибрации ниже 150 Гц;

• lowpass=f=7500 — отсекает высокочастотный шум выше 7,5 к=КГц;

• equalizer=f=180:t=q:w=1:g=-6 — подавляет резонанс и «бубнение» голоса в области 180 Гц (важно для распознавания голоса лектора, записанного в учебной аудитории);

• afftdn=nf=-28 — включает частотное шумоподавление;

• dynaudnorm=f=200:g=18 — выравнивает громкость речи по всему файлу

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

• -ar 16000 — частота дискретизации 16 КГц;

• -ac 1 — монофонический файл;

• -c:a pcm_s16le — несжатый WAV, 16 бит

На рис. 6 показан исходный звуковой файл записи лекции в окне программы Ocenaudio, а на рис. 7 — результаты обработки программой ffmpeg с указанными выше параметрами.

Как видите, звук стал монофоническим, частота дискретизации изменилась и стала равной 16000 Гц, была выровнена громкость речи по всему файлу.

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

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

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

Для экспериментов с потоковым распознаванием речи я подключил веб-камеру Logitech через USB к микрокомпьютеру Репка 4 отечественной сборки (рис. 8).

Этот компьютер играет роль клиента для сервера потокового распознавания речи.

Ниже я рассмотрю другой вариант — использование в качестве клиента настольного компьютера или ноутбука с ОС Microsoft Windows с микрофоном или веб-камерой.

Установка сервера для потокового распознавания

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

Создайте виртуальное окружение и обновите pip:

$ python3 -m venv /home/ubuntu/asr-public-streaming
$ source /home/ubuntu/asr-public-streaming/bin/activate
$ pip install --upgrade pip

На следующем шаге нужно установить CUDA 12.0, предварительно выполнив очистку:

$ sudo apt --purge remove "*cuda*"
$ sudo rm -f /etc/apt/sources.list.d/cuda*
$ sudo rm -f /usr/share/keyrings/cuda*
$ sudo apt update
$ wget https://developer.download.nvidia.com/compute/cuda/12.0.1/local_installers/cuda_12.0.1_525.85.12_linux.run
chmod +x cuda_12.0.1_525.85.12_linux.run
sudo ./cuda_12.0.1_525.85.12_linux.run --toolkit --silent --override

Добавьте к файлу ~/.bashrc экспорт путей к CUDA:

$ echo 'export PATH=/usr/local/cuda-12.0/bin:$PATH' >> ~/.bashrc
$ echo 'export 
LD_LIBRARY_PATH=/usr/local/cuda-12.0/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
$ source ~/.bashrc

После выполнения этих действий проверьте версию установленного CUDA:

$ nvcc --version
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2023 NVIDIA Corporation
Built on Fri_Jan__6_16:45:21_PST_2023
Cuda compilation tools, release 12.0, V12.0.140
Build cuda_12.0.r12.0/compiler.32267302_0

Теперь осталось установить необходимые пакеты и можно приступать к запуску сервера:

$ source /home/ubuntu/asr-public-streaming/bin/activate
$ pip install fastapi 'uvicorn[standard]' faster-whisper[all] torch torchvision torchaudio

Запуск потокового сервера

Перед запуском сервера активируйте настройки в файле ~/.bashrc и виртуальную среду:

$ source ~/.bashrc
$ source /home/ubuntu/asr-public-streaming/bin/activate

С целью тестирования сервер можно запустить из консоли простой командой:

$ python asr_server_async.py

После запуска программа будет ожидать подключения клиента на порту 8000 (рис. 9).

Программа asr_server_async.py доступна в моём репозитории.

Краткое описание программы asr_server_async

Программа автоматического распознавания речи реализована как асинхронный сервер на базе FastAPI и модели Faster-Whisper. Она получает поток данных аудио через WebSocket, обрабатывает его в реальном времени и отправляет распознанный текст обратно клиенту.

Клиент подключается к маршруту /ws/asr. Сервер получает данные от клиента и преобразует их в массив numpy с типом int16, накапливая в буфере.

Поле накопления данных за три секунды данные преобразуются в формат float32 и передаются в модель для распознавания речи. Процесс распознавания запускается асинхронно с применением asyncio.to_thread, не блокируя основной цикл сервера.

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

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

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

Дополнительно сервер предоставляет еще несколько маршрутов:

• /recordings — просмотр всех сохраненных записей в режиме отладки;

• /recordings/clear — удаление всех записей;

• /health — проверка состояния сервера, включая используемое устройство (CPU/GPU), модель и режим отладки

Клиент сервера потокового распознавания на базе Repka Pi 4

В качестве клиента потокового сервера можно использовать микрокомпьютер отечественного производства Repka Pi 4. Я подготовил для него программу mic_client_arecord_public.py.

Для установки и настройки клиента сначала скачайте нужную вам прошивку Repka OS на сайте Repka-Pi, запишите её на карту SD и выполните загрузку Repka Pi 4 с этой карты. 

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

sudo apt update
sudo apt install -y alsa-utils python3 python3-pip

Проверьте ALSA:

arecord –version
arecord: version 1.2.6 by Jaroslav Kysela <perex@perex.cz>

Создайте и активируйте виртуальное окружение:

apt install python3.10-venv
python3 -m venv venv
source venv/bin/activate

Установите необходимые библиотеки:

pip install --upgrade pip
pip install numpy websocket-client torch silero-vad
pip install websockets

Для проверки микрофона прежде всего посмотрите список устройств:

arecord -l
**** Список CAPTURE устройств ****
карта 0: ac200audio [ac200-audio], устройство 0: 508f000.i2s-ac200-dai ac200-dai-0 [508f000.i2s-ac200-dai ac200-dai-0]
  Подустройства: 1/1
  Подустройство №0: subdevice #0
карта 1: U0x46d0x825 [USB Device 0x46d:0x825], устройство 0: USB Audio [USB Audio]
  Подустройства: 1/1
  Подустройство №0: subdevice #0

В данном случае я подключил веб-камеру Logitech с микрофоном к разъёму USB. Микрофон был обнаружен на карте 1, устройство 0. Для проверки запустите команду arecord и говорите в микрофон:

arecord -D plughw:1,0 -f S16_LE -r 16000 -c 1 test.wav

Чтобы прервать запись, нажмите комбинацию клавиш Ctrl+C. Прослушайте запись командой aplay:

aplay test.wav

Теперь, находясь в виртуальном окружении, запустите клиент потокового сервера:

cd venv
# python3 mic_client_arecord_public.py

После подключения к серверу клиента произносите слова в микрофон и наблюдайте за консолью клиента (рис. 10) и сервера (рис. 11).

Распознанный текст не совсем соответствует оригиналу, но смысл сохранился (а рифма — нет).

Клиент сервера потокового распознавания для Windows

Я также подготовил и протестировал программу клиента для Microsoft Windows 11 asr_client_enhanced.py. Она полностью совместима с рассмотренным выше сервером потокового распознавания.

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

Если запустить программу в консоли, она будет отправлять данные на сервер и выводить результаты распознавания (рис. 12).

Установка сервера для работы с Parakeet

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

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

Первым делом обновим систему и проверим установку основных пакетов:

sudo apt-get update
sudo apt-get upgrade -y
sudo apt-get install -y python3.10 python3.10-venv python3.10-dev
sudo apt-get install -y libsndfile1 ffmpeg sox cmake build-essential git curl wget

Далее установим NVIDIA CUDA Toolkit:

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update
sudo apt-get install -y cuda-toolkit-12-2

Проверим установку:

python3 --version
python 3.10.12

nvcc –-version
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2023 NVIDIA Corporation
Built on Fri_Jan__6_16:45:21_PST_2023
Cuda compilation tools, release 12.0, V12.0.140
Build cuda_12.0.r12.0/compiler.32267302_0
nvidia-smi

В результатах работы этой команды должна быть строка:

NVIDIA-SMI 535.274.02 Driver Version: 535.274.02 CUDA Version: 12.2

Создадим, настроим и активируем виртуальное окружение:

mkdir -p /home/ubuntu/parakeet_v3
cd /home/ubuntu/parakeet_v3
python3.10 -m venv venv
source venv/bin/activate
pip install --upgrade pip

Дальше перейдём к установке зависимостей. Прежде всего установим PyTorch и CUDA 11.8:

pip install torch==2.1.0 torchaudio==2.1.0 --index-url https://download.pytorch.org/whl/cu118

Установим зависимости для NeMo:

pip install Cython==0.29.36
pip install huggingface-hub==0.23.0
pip install transformers==4.33.3
pip install omegaconf==2.3.0
pip install hydra-core==1.3.2
pip install pytorch-lightning==2.0.7
pip install torchmetrics==1.8.2

Устанавливаем nemo-toolkit:

pip install nemo-toolkit==1.21.0

Затем устанавливаем пакеты для обработки аудио и веб-сервера:

pip install soundfile==0.13.1
pip install librosa==0.11.0
pip install fastapi==0.104.1
pip install uvicorn[standard]==0.24.0
pip install websockets==12.0

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

pip install numpy==1.23.5
pip install sentencepiece==0.1.99
pip install tokenizers==0.13.3
pip install onnx==1.20.1
pip install tensorboard==2.20.0
pip install wget==3.2
pip install pandas==2.3.3
pip install inflect==7.5.0
pip install nltk==3.9.2
pip install joblib==1.5.3
pip install pillow==12.1.0
pip install pooch==1.8.2
pip install audioread==3.1.0
pip install resampy==0.4.3
pip install colorama==0.4.6
pip install webdataset==0.1.62
pip install pyannote.core==5.0.0
pip install pyannote.metrics==3.2.1
pip install pyannote.database==5.1.3
pip install editdistance==0.8.1
pip install jiwer==4.0.0
pip install ipython==8.38.0

На этом этапе не помешает проверить установку основных пакетов:

python -c "
import torch
print(f'PyTorch: {torch.__version__}')
print(f'CUDA доступна: {torch.cuda.is_available()}')
if torch.cuda.is_available():
    print(f'GPU: {torch.cuda.get_device_name(0)}')
"

Программа должна вывести на консоль:

PyTorch: 2.9.1+cu128
CUDA доступна: True
GPU: NVIDIA A2

Далее установите youtokentome из исходников:

cd /tmp
git clone https://github.com/vkcom/youtokentome.git
cd youtokentome
git checkout v1.0.6
pip install Cython==0.29.36 setuptools==65.5.0
python setup.py build_ext --inplace
python setup.py install

Проверьте NeMo:

python -c "
import nemo.collections.asr as nemo_asr
print('NeMo импортирован успешно')
"

Переустановите numpy на правильную версию:

pip uninstall -y numpy
pip install numpy==1.23.5

Теперь сервер готов к запуску.

Краткое описание программы asr_server_optimized

Программа asr_server_optimized.py представляет собой сервер автоматического распознавания речи с использованием модели NVIDIA Parakeet v3, NVIDIA NeMo и FastAPI.

Сервер принимает аудиопоток от клиентов по WebSocket, распознаёт в нём текст и возвращает результаты распознавания в реальном времени. В программе сервера реализованы такие маршруты:

• ws/asr для работы с аудиопотоком через WebSocket;

• ws/health для проверки состояния сервера и доступности модели

Аналогично рассмотренному выше серверу на базе модели Faster-Whisper, этот сервер собирает данные аудио в буфер и запускает распознавание в отдельном потоку с помощью ThreadPoolExecutor.

Этот сервер способен работать с теми же самыми клиентами, что и ранее описанный сервер потокового распознавания на базе модели Faster-Whisper.

Запуск сервера с Parakeet

Перейдите в каталог проекта и запустите программу сервера asr_server_optimized.py:

cd /home/ubuntu/parakeet_v3
source venv/bin/activate
python asr_server_optimized.py

Результаты работы сервера видны на консоли (рис. 13).

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

Установка программы распознавания речи в Docker

Для промышленного применения удобнее использовать Docker. Это ускоряет развёртывание программы и даёт возможность масштабирования.

Займёмся созданием контейнера для запуска программы whisper_pyannote_gpu_v3.py распознавания речи в файлах, о которой я рассказывал выше.

Сразу скажу, что перед использованием Docker нужно установить на сервер (не в контейнер) драйвер NVIDIA с помощью скрипта install_nvidia_definite_public.sh, а также NVIDIA Container Toolkit.

Установка Docker на сервер Ubuntu

Установку Docker можно выполнить следующей последовательностью команд:

sudo apt install -y ca-certificates curl gnupg  lsb-release
sudo mkdir -p /etc/apt/keyrings
 curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
sudo usermod -aG docker $USER
 newgrp docker

После установки проверьте работу Docker:

docker run hello-world

Она должна вывести на консоль приглашение, содержащее строку «Hello from Docker!».

Установка NVIDIA Container Toolkit

Далее установите NVIDIA Container Toolkit с помощью следующей последовательности команд:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt update
 sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker

После установки перезапустите сервис Docker:

sudo systemctl restart docker

Проверьте доступность GPU:

docker run --rm --gpus all nvidia/cuda:12.1.1-base-ubuntu22.04 nvidia-smi

Сборка контейнера

Создайте каталог для сборки контейнера, например, asr-public2, и сделайте его текущим:

cd asr-public2

Создайте здесь подкаталоги input и results для хранения звуковых файлов и для результатов распознавания, соответственно.

Также создайте в этом каталоге файлы Dockerfile, docker-compose.yml и requirements.txt. Все эти файлы доступны в моём репозитории на Github.

Далее, находясь в каталоге asr-public2, соберите контейнер:

docker compose build

Запуск контейнера

Для запуска контейнера создайте переменную среды HF_TOKEN:

export HF_TOKEN=hf_*****

Далее запустите контейнер:

docker compose up

Контейнер можно запустить и с указанием параметров:

docker run --rm --gpus all 
   -e HF_TOKEN=hf_******* 
   -v $(pwd)/input:/app/input 
   -v $(pwd)/results:/app/results 
   asr-public2-whisper-asr 
   /app/input/fm-records_25.wav 
   --whisper-model large-v3 
   --language ru 
   --export-all 
   --hf-token hf_*******

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

Что дальше

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

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

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

Автор @AlexandreFrolov

НЛО прилетело и оставило здесь промокод для читателей нашего блога:
-15% на заказ любого VDS (кроме тарифа Прогрев) — HABRFIRSTVDS.