Речевые технологии Python: как создать умный голосовой интерфейс

import speech_recognition as sr

# Инициализация распознавателя
r = sr.Recognizer()

# Запись аудио с микрофона
with sr.Microphone() as source:
print("Скажите что-нибудь...")
audio = r.listen(source)

try:
# Распознавание с использованием Google Speech Recognition
text = r.recognize_google(audio, language="ru-RU")
print(f"Вы сказали: {text}")
except sr.UnknownValueError:
print("Не удалось распознать речь")
except sr.RequestError:
print("Ошибка сервиса распознавания")

import speech_recognition as sr

recognizer = sr.Recognizer()

with sr.Microphone() as source:
print("Говорите...")
audio = recognizer.listen(source)

# Используем Sphinx для офлайн-распознавания
try:
text = recognizer.recognize_sphinx(audio, language="ru-RU")
print(f"Sphinx распознал: {text}")
except sr.UnknownValueError:
print("Sphinx не распознал речь")
except sr.RequestError as e:
print(f"Ошибка Sphinx: {e}")

import numpy as np
from deepspeech import Model
import wave

# Загружаем предобученную модель
model_path = 'deepspeech-0.9.3-models.pbmm'
model = Model(model_path)

# Можно добавить языковую модель для повышения точности
# model.enableExternalScorer('scorer.scorer')

# Открываем аудиофайл для распознавания
with wave.open('audio.wav', 'rb') as w:
rate = w.getframerate()
frames = w.getnframes()
buffer = w.readframes(frames)

# Преобразуем аудио в формат, понятный DeepSpeech
audio = np.frombuffer(buffer, dtype=np.int16)

# Распознаем текст
text = model.stt(audio)
print(f"Распознанный текст: {text}")

import json
from vosk import Model, KaldiRecognizer
import pyaudio

# Загрузка модели
model = Model("model")
recognizer = KaldiRecognizer(model, 16000)

# Настройка аудиопотока
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16, channels=1, rate=16000, 
input=True, frames_per_buffer=8000)
stream.start_stream()

print("Слушаю...")
while True:
data = stream.read(4000)
if len(data) == 0:
break
if recognizer.AcceptWaveform(data):
result = json.loads(recognizer.Result())
print(result["text"])

import torch
from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor
import librosa

# Загрузка модели и процессора
processor = Wav2Vec2Processor.from_pretrained("jonatasgrosman/wav2vec2-large-xlsr-53-russian")
model = Wav2Vec2ForCTC.from_pretrained("jonatasgrosman/wav2vec2-large-xlsr-53-russian")

# Загрузка и предобработка аудиофайла
audio_input, rate = librosa.load("input.wav", sr=16000)
input_values = processor(audio_input, return_tensors="pt", sampling_rate=16000).input_values

# Распознавание
with torch.no_grad():
logits = model(input_values).logits
predicted_ids = torch.argmax(logits, dim=-1)
transcription = processor.batch_decode(predicted_ids)[0]

print(f"Транскрипция: {transcription}")

import pyttsx3

# Инициализация движка
engine = pyttsx3.init()

# Настройка параметров голоса
voices = engine.getProperty('voices')
# Выбор голоса (обычно индекс 0 – мужской, 1 – женский)
engine.setProperty('voice', voices[1].id)
# Настройка скорости речи (по умолчанию 200)
engine.setProperty('rate', 150)

# Синтез речи
text = "Привет, мир! Я синтезированный голос, созданный с помощью Python и pyttsx3."
engine.say(text)
engine.runAndWait()

# Сохранение в файл
engine.save_to_file(text, 'output.mp3')
engine.runAndWait()

from gtts import gTTS
import os

# Текст для преобразования
text = "Технологии синтеза речи на Python открывают новые возможности для разработчиков."

# Создание объекта gTTS
tts = gTTS(text=text, lang='ru', slow=False)

# Сохранение в файл
tts.save('speech.mp3')

# Воспроизведение (для Linux/Mac)
os.system('mpg321 speech.mp3')
# Для Windows
# os.system('start speech.mp3')

# Установка через pip: pip install TTS

from TTS.utils.synthesizer import Synthesizer
from TTS.utils.manage import ModelManager

# Инициализация менеджера моделей
model_manager = ModelManager()

# Выбор модели
model_path, config_path, model_item = model_manager.download_model("tts_models/ru/cv/tacotron2-DDC")

# Инициализация синтезатора
synthesizer = Synthesizer(
model_path,
config_path,
None,
None,
None
)

# Синтез речи
text = "Нейронные сети произвели революцию в качестве синтезированной речи."
outputs = synthesizer.tts(text)
synthesizer.save_wav(outputs, "output.wav")

import boto3

# Настройка клиента Polly
polly = boto3.client('polly', 
region_name='eu-west-1', 
aws_access_key_id='YOUR_ACCESS_KEY',
aws_secret_access_key='YOUR_SECRET_KEY')

# Текст для синтеза
text = "Облачные сервисы синтеза речи обеспечивают профессиональное качество озвучки."

# Синтез речи
response = polly.synthesize_speech(
Text=text,
OutputFormat='mp3',
VoiceId='Tatyana' # Русский женский голос
)

# Сохранение в файл
with open('polly_speech.mp3', 'wb') as file:
file.write(response['AudioStream'].read())

# Пример использует PyTorch и предобученные модели

import torch
from tacotron2_model import Tacotron2
from waveglow_model import WaveGlow

# Загрузка моделей
tacotron2 = Tacotron2().cuda()
tacotron2.load_state_dict(torch.load('tacotron2_weights.pt'))
tacotron2.eval()

waveglow = WaveGlow().cuda()
waveglow.load_state_dict(torch.load('waveglow_weights.pt'))
waveglow.eval()

# Подготовка текста
from text_preprocessing import text_to_sequence
text = "Нейронный синтез речи достиг феноменального качества."
sequence = torch.tensor(text_to_sequence(text)).cuda()

# Генерация мел-спектрограммы
with torch.no_grad():
mel_outputs = tacotron2.inference(sequence)

# Преобразование в аудио
with torch.no_grad():
audio = waveglow.inference(mel_outputs)
audio_np = audio[0].data.cpu().numpy()

# Сохранение аудио
import scipy.io.wavfile as wavfile
wavfile.write("neural_tts_output.wav", 22050, audio_np)

from gtts import gTTS
import os

# SSML-подобная разметка (gTTS поддерживает ограниченный набор тегов)
text = "Обычный текст. <emphasis level='strong'>Выделенный текст.</emphasis> Пауза..."

# Подготовка текста (для gTTS нужна ручная обработка)
text = text.replace("<emphasis level='strong'>", "")
text = text.replace("</emphasis>", "")
text = text.replace("Пауза...", "Пауза. . .") # Добавляем паузы через точки

tts = gTTS(text=text, lang='ru')
tts.save('ssml_example.mp3')
os.system('mpg321 ssml_example.mp3')

# Установка необходимых библиотек
pip install SpeechRecognition pyttsx3 PyAudio requests python-dateutil pywhatkit

import speech_recognition as sr
import pyttsx3
import datetime
import requests
import os
import webbrowser
import json
from dateutil import parser
import pywhatkit

class VoiceAssistant:
def __init__(self, name="Алиса"):
self.name = name

# Инициализация распознавателя речи
self.recognizer = sr.Recognizer()

# Инициализация синтезатора речи
self.speaker = pyttsx3.init()
voices = self.speaker.getProperty('voices')
# Выбираем женский голос (если доступен)
for voice in voices:
if "female" in voice.name.lower():
self.speaker.setProperty('voice', voice.id)
break

# Настраиваем скорость речи
self.speaker.setProperty('rate', 150)

self.speak(f"{self.name} готова помочь вам!")

def speak(self, text):
"""Произносит текст"""
print(f"{self.name}: {text}")
self.speaker.say(text)
self.speaker.runAndWait()

def listen(self):
"""Слушает пользователя и возвращает распознанный текст"""
with sr.Microphone() as source:
print("Слушаю...")
self.recognizer.adjust_for_ambient_noise(source)
audio = self.recognizer.listen(source)

try:
text = self.recognizer.recognize_google(audio, language="ru-RU")
print(f"Вы сказали: {text}")
return text.lower()
except sr.UnknownValueError:
self.speak("Извините, я вас не поняла")
return ""
except sr.RequestError:
self.speak("Извините, сервис распознавания речи недоступен")
return ""

def process_command(self, command):
"""Обрабатывает команду пользователя"""
# Обработка приветствия
if "привет" in command or "здравствуй" in command:
self.speak(f"Привет! Чем я могу помочь?")

# Узнать время
elif "время" in command or "который час" in command:
now = datetime.datetime.now()
time_str = now.strftime("%H:%M")
self.speak(f"Сейчас {time_str}")

# Узнать дату
elif "дата" in command or "какой сегодня день" in command:
now = datetime.datetime.now()
date_str = now.strftime("%d %B %Y")
self.speak(f"Сегодня {date_str}")

# Погода
elif "погода" in command:
self.get_weather()

# Открыть приложение
elif "открой" in command:
app_name = command.split("открой", 1)[1].strip()
self.open_application(app_name)

# Поиск в интернете
elif "найди" in command or "поиск" in command or "загугли" in command:
search_term = command.split("найди", 1)[1].strip() if "найди" in command else \
command.split("поиск", 1)[1].strip() if "поиск" in command else \
command.split("загугли", 1)[1].strip()
self.search_web(search_term)

# Напоминание
elif "напомни" in command:
reminder_text = command.split("напомни", 1)[1].strip()
self.set_reminder(reminder_text)

# Выключение ассистента
elif "пока" in command or "выключись" in command or "до свидания" in command:
self.speak("До свидания! Обращайтесь, если понадоблюсь.")
return False

# Неизвестная команда
else:
self.speak("Извините, я не знаю такой команды")

return True

def get_weather(self):
"""Получает информацию о погоде"""
api_key = "YOUR_OPENWEATHERMAP_API_KEY" # Замените на свой ключ
city = "Moscow" # Город по умолчанию

url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric&lang=ru"

try:
response = requests.get(url)
data = json.loads(response.text)
temperature = data["main"]["temp"]
description = data["weather"][0]["description"]

self.speak(f"В городе {city} сейчас {description}, температура {temperature} градусов Цельсия")
except:
self.speak("Извините, не могу получить информацию о погоде")

def open_application(self, app_name):
"""Открывает приложение"""
app_map = {
"браузер": "chrome",
"блокнот": "notepad",
"калькулятор": "calc"
}

try:
if app_name in app_map:
os.system(f"start {app_map[app_name]}")
self.speak(f"Открываю {app_name}")
else:
self.speak(f"Извините, я не знаю, как открыть {app_name}")
except:
self.speak("Произошла ошибка при попытке открыть приложение")

def search_web(self, query):
"""Ищет информацию в интернете"""
self.speak(f"Ищу информацию о {query}")
try:
pywhatkit.search(query)
# Альтернативный вариант:
# url = f"https://www.google.com/search?q={query.replace(' ', '+')}"
# webbrowser.open(url)
except:
self.speak("Произошла ошибка при попытке поиска")

def set_reminder(self, text):
"""Устанавливает напоминание"""
self.speak(f"Я напомню вам о: {text}")
# Здесь можно добавить реальную логику напоминаний
# Например, с использованием планировщика задач

def run(self):
"""Запускает ассистента в режиме ожидания команд"""
running = True

while running:
command = self.listen()
if self.name.lower() in command: # Активация по ключевому слову
command = command.replace(self.name.lower(), "").strip()
running = self.process_command(command)

# Добавьте здесь дополнительные триггеры активации, если нужно

if __name__ == "__main__":
assistant = VoiceAssistant()
assistant.run()

# Установка библиотеки
pip install spacy
python -m spacy download ru_core_news_sm

import spacy

class ImprovedVoiceAssistant(VoiceAssistant):
def __init__(self, name="Алиса"):
super().__init__(name)
self.nlp = spacy.load("ru_core_news_sm")

def process_command(self, command):
# Анализируем команду с помощью spaCy
doc = self.nlp(command)

# Извлекаем сущности
entities = {ent.label_: ent.text for ent in doc.ents}

# Извлекаем ключевые глаголы (действия)
verbs = [token.lemma_ for token in doc if token.pos_ == "VERB"]

# Теперь можно использовать эту информацию для более точной обработки команд
# Например, определить действие по глаголу, а объект – по сущностям

# Далее идет логика из базовой версии...
return super().process_command(command)

class ContextAwareAssistant(ImprovedVoiceAssistant):
def __init__(self, name="Алиса"):
super().__init__(name)
self.context = {
"current_topic": None,
"last_entities": {},
"dialog_state": "initial",
"history": []
}

def process_command(self, command):
# Сохраняем команду в историю
self.context["history"].append(command)

# Если есть активный контекст, используем его
if self.context["dialog_state"] == "awaiting_confirmation":
if "да" in command or "подтверждаю" in command:
# Выполняем отложенное действие
action = self.context["pending_action"]
self.speak(f"Выполняю: {action}")
# Сбрасываем состояние диалога
self.context["dialog_state"] = "initial"
return True
elif "нет" in command or "отмена" in command:
self.speak("Действие отменено")
self.context["dialog_state"] = "initial"
return True

# Анализируем команду как обычно
return super().process_command(command)

def set_reminder(self, text):
# Пример использования контекста
self.context["dialog_state"] = "awaiting_confirmation"
self.context["pending_action"] = f"напомнить о {text}"
self.speak(f"Подтвердите установку напоминания: {text}")

import threading
import queue

class ResponsiveAssistant(ContextAwareAssistant):
def __init__(self, name="Алиса"):
super().__init__(name)
self.command_queue = queue.Queue()
self.processing_thread = threading.Thread(target=self._process_commands)
self.processing_thread.daemon = True
self.processing_thread.start()

def _process_commands(self):
"""Отдельный поток для обработки команд"""
while True:
command = self.command_queue.get()
if command is None: # Сигнал для завершения
break
super().process_command(command)
self.command_queue.task_done()

def process_command(self, command):
"""Добавляет команду в очередь и сразу возвращает управление"""
self.command_queue.put(command)
return True

def shutdown(self):
"""Корректное завершение работы ассистента"""
self.command_queue.put(None)
self.processing_thread.join()
self.speak("Выключаюсь. До свидания!")

import speech_recognition as sr
from pydub import AudioSegment
from pydub.utils import make_chunks

def transcribe_long_audio(file_path, chunk_length_ms=60000):
"""
Транскрибирует длинные аудиофайлы, разбивая их на управляемые фрагменты
"""
audio = AudioSegment.from_file(file_path)
chunks = make_chunks(audio, chunk_length_ms)

recognizer = sr.Recognizer()
full_transcript = ""

for i, chunk in enumerate(chunks):
# Сохраняем временный файл для обработки
chunk_name = f"temp_chunk_{i}.wav"
chunk.export(chunk_name, format="wav")

# Распознаем речь в фрагменте
with sr.AudioFile(chunk_name) as source:
audio_data = recognizer.record(source)
try:
text = recognizer.recognize_google(audio_data, language="ru-RU")
full_transcript += text + " "
print(f"Фрагмент {i}: {text}")
except sr.UnknownValueError:
print(f"Не удалось распознать фрагмент {i}")
except sr.RequestError:
print("API недоступен")

# Удаляем временный файл
import os
os.remove(chunk_name)

return full_transcript

# Пример использования
transcript = transcribe_long_audio("lecture.mp3")
with open("lecture_transcript.txt", "w", encoding="utf-8") as f:
f.write(transcript)

import numpy as np
import librosa
from sklearn.mixture import GaussianMixture

class VoiceAuthenticator:
def __init__(self):
self.models = {} # Хранение моделей пользователей

def extract_features(self, audio_path):
"""Извлекает MFCCs из аудиофайла"""
y, sr = librosa.load(audio_path, sr=None)
mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
return mfccs.T

def train_model(self, user_id, audio_path):
"""Обучает модель для конкретного пользователя"""
features = self.extract_features(audio_path)
gmm = GaussianMixture(n_components=16, covariance_type='diag')
gmm.fit(features)
self.models[user_id] = gmm
print(f"Модель для пользователя {user_id} обучена")

def authenticate(self, audio_path, threshold=0.6):
"""Проверяет аутентичность голоса"""
features = self.extract_features(audio_path)

max_score = -float('inf')
best_match = None

for user_id, model in self.models.items():
score = model.score(features)
if score > max_score:
max_score = score
best_match = user_id

# Нормализация счета для удобства интерпретации
normalized_score = 1 / (1 + np.exp(-max_score / 100))

if normalized_score >= threshold:
return True, best_match, normalized_score
else:
return False, None, normalized_score

# Пример использования
authenticator = VoiceAuthenticator()

# Регистрация пользователей
authenticator.train_model("user1", "voice_samples/user1_enroll.wav")
authenticator.train_model("user2", "voice_samples/user2_enroll.wav")

# Аутентификация
is_authentic, user, confidence = authenticator.authenticate("voice_samples/test.wav")
if is_authentic:
print(f"Пользователь {user} аутентифицирован с уверенностью {confidence:.2f}")
else:
print(f"Аутентификация не удалась. Уверенность: {confidence:.2f}")

import speech_recognition as sr
from googletrans import Translator
from gtts import gTTS
import os

def real_time_translator(source_lang='ru', target_lang='en'):
"""
Распознаёт речь на исходном языке, переводит и озвучивает на целевом языке
"""
recognizer = sr.Recognizer()
translator = Translator()

with sr.Microphone() as source:
print(f"Говорите на {source_lang}...")
recognizer.adjust_for_ambient_noise(source)
audio = recognizer.listen(source)

try:
# Распознаём речь
text = recognizer.recognize_google(audio, language=source_lang)
print(f"Распознано ({source_lang}): {text}")

# Переводим
translation = translator.translate(text, src=source_lang, dest=target_lang)
print(f"Перевод ({target_lang}): {translation.text}")

# Озвучиваем перевод
tts = gTTS(text=translation.text, lang=target_lang)
tts.save("tra

**Читайте также**
- [TF-IDF в Python: превращаем текст в векторы для машинного обучения](/python/python-i-sklearn-dlya-tf-idf/)
- [Техники обучения ML-моделей на малых данных: основные подходы](/python/obuchenie-na-nebolshom-obueme-dannyh/)
- [Оптимизация классификаторов Grid Search: настраиваем Random Forest и CatBoost](/python/random-forest-classifier-v-sklearn-i-catboost-s-grid-search/)
- [Алгоритм K-Nearest Neighbors: принципы работы и применение в ML](/python/k-nearest-neighbors-v-sklearn/)
- [15 образовательных ресурсов для изучения нейросетей: от основ до мастерства](/python/obuchenie-nejrosetej-onlajn-platnye-i-besplatnye-resursy/)
- [Наивный байесовский классификатор: применение в ML и реализация](/python/naivnyj-bajesovskij-klassifikator-v-python/)
- [Обучение с подкреплением на Python: как создавать самообучающиеся системы](/python/obuchenie-s-podkrepleniem-na-python/)
- [Машинное обучение на Python: от базовых навыков к экспертизе](/python/obuchenie-mashinnogo-obucheniya-na-python/)