Распознавание речи и лиц на Python: техники создания умных систем

# Создаем виртуальное окружение
python -m venv venv_recognition

# Активируем его
# Windows
venv_recognition\Scripts\activate
# Linux/MacOS
source venv_recognition/bin/activate

pip install SpeechRecognition
pip install pyaudio
# На Windows может потребоваться установка PyAudio через whl-файл
# pip install pipwin
# pipwin install pyaudio

pip install opencv-python
pip install dlib
# Если возникают проблемы с установкой dlib, можно использовать:
# pip install cmake
# pip install https://github.com/jloh02/dlib/releases/download/v19.22/dlib-19.22.99-cp310-cp310-win_amd64.whl

pip install face-recognition

# test_environment.py
import cv2
import speech_recognition as sr
try:
import dlib
print("dlib успешно импортирован")
except:
print("Проблема с импортом dlib")

# Тестируем OpenCV
print(f"OpenCV версия: {cv2.__version__}")

# Тестируем SpeechRecognition
recognizer = sr.Recognizer()
print(f"SpeechRecognition доступен: {recognizer is not None}")

print("Настройка окружения завершена успешно!")

import speech_recognition as sr

def recognize_speech_from_mic():
# Инициализируем распознаватель
recognizer = sr.Recognizer()

# Используем микрофон как источник аудио
with sr.Microphone() as source:
print("Настраиваюсь на окружающий шум...")
# Настройка на окружающий шум для лучшего распознавания
recognizer.adjust_for_ambient_noise(source, duration=1)
print("Слушаю...")

# Записываем аудио
audio = recognizer.listen(source)
print("Обрабатываю...")

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

# Запускаем функцию распознавания
if __name__ == "__main__":
while True:
text = recognize_speech_from_mic()
if "выход" in text.lower():
print("Завершение работы...")
break

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

def recognize_from_file(file_path):
recognizer = sr.Recognizer()

with sr.AudioFile(file_path) as source:
audio = recognizer.record(source) # Читаем весь файл

try:
text = recognizer.recognize_google(audio, language="ru-RU")
print(f"Текст из файла: {text}")
return text
except sr.UnknownValueError:
print("Google Speech Recognition не распознал аудио")
return ""
except sr.RequestError as e:
print(f"Ошибка сервиса Google Speech Recognition: {e}")
return ""

def process_command(text):
text = text.lower()

if "открыть файл" in text:
print("Открываю файловый менеджер...")
# Здесь код для открытия файлового менеджера

elif "включить музыку" in text:
print("Включаю музыкальный плеер...")
# Код для запуска музыкального плеера

elif "какая погода" in text:
print("Проверяю прогноз погоды...")
# Код для получения прогноза погоды

elif "время" in text:
from datetime import datetime
current_time = datetime.now().strftime("%H:%M")
print(f"Текущее время: {current_time}")

else:
print(f"Команда '{text}' не распознана")

# В основном цикле
while True:
text = recognize_speech_from_mic()
if text:
process_command(text)
if "выход" in text.lower():
break

import cv2
import numpy as np

def detect_faces(image_path):
# Загружаем изображение
image = cv2.imread(image_path)
# Конвертируем в оттенки серого для лучшей работы детектора
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Загружаем предобученный каскадный классификатор Хаара
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

# Обнаруживаем лица
faces = face_cascade.detectMultiScale(
gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30)
)

print(f"Найдено {len(faces)} лиц!")

# Рисуем прямоугольники вокруг лиц
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)

# Отображаем результат
cv2.imshow("Обнаруженные лица", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

return faces

# Пример использования
faces = detect_faces("group_photo.jpg")

import cv2
import dlib
import numpy as np
from scipy.spatial import distance

# Загружаем детектор лиц и предсказатель ориентиров
detector = dlib.get_frontal_face_detector()
# Путь к файлу shape_predictor_68_face_landmarks.dat должен быть настроен
predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
# Загружаем модель для создания векторов признаков лица
face_rec_model = dlib.face_recognition_model_v1("dlib_face_recognition_resnet_model_v1.dat")

def get_face_encodings(image_path):
# Загружаем изображение
image = cv2.imread(image_path)
# Конвертируем в RGB (dlib ожидает RGB, а OpenCV использует BGR)
rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Обнаруживаем лица
faces = detector(rgb_image)

# Список для хранения векторов признаков
face_encodings = []

for face in faces:
# Получаем ориентиры (landmarks) для лица
landmarks = predictor(rgb_image, face)

# Создаем вектор признаков для лица
face_encoding = face_rec_model.compute_face_descriptor(rgb_image, landmarks)

# Преобразуем в numpy массив для удобства
face_encodings.append(np.array(face_encoding))

return face_encodings, faces

def compare_faces(known_encoding, unknown_encoding, tolerance=0.6):
# Вычисляем евклидово расстояние между векторами
face_distance = distance.euclidean(known_encoding, unknown_encoding)

# Возвращаем True, если расстояние меньше заданного порога
return face_distance < tolerance, face_distance

# Создаем базу данных известных лиц
known_faces = {
"Иван": get_face_encodings("ivan.jpg")[0][0],
"Мария": get_face_encodings("maria.jpg")[0][0],
"Алексей": get_face_encodings("alexey.jpg")[0][0]
}

# Функция для идентификации лица
def identify_face(image_path):
# Получаем кодировки лиц с изображения
unknown_encodings, faces = get_face_encodings(image_path)

# Загружаем изображение для отображения результатов
image = cv2.imread(image_path)

# Для каждого обнаруженного лица
for i, unknown_encoding in enumerate(unknown_encodings):
# Имя лица и минимальное расстояние
best_match_name = "Неизвестный"
best_match_distance = float("inf")

# Сравниваем с каждым известным лицом
for name, known_encoding in known_faces.items():
matched, face_distance = compare_faces(known_encoding, unknown_encoding)

if matched and face_distance < best_match_distance:
best_match_name = name
best_match_distance = face_distance

# Получаем координаты лица
face = faces[i]
x, y, w, h = face.left(), face.top(), face.width(), face.height()

# Рисуем прямоугольник и подписываем имя
cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)
cv2.putText(image, f"{best_match_name} ({best_match_distance:.2f})", 
(x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

# Отображаем результат
cv2.imshow("Идентифицированные лица", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Пример использования
identify_face("test_photo.jpg")

def recognize_faces_in_video():
# Инициализируем видеокамеру
video_capture = cv2.VideoCapture(0)

if not video_capture.isOpened():
print("Ошибка при открытии камеры")
return

while True:
# Считываем кадр
ret, frame = video_capture.read()

if not ret:
print("Ошибка при захвате кадра")
break

# Конвертируем в RGB
rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

# Обнаруживаем лица
faces = detector(rgb_frame)

for face in faces:
# Получаем ориентиры
landmarks = predictor(rgb_frame, face)

# Создаем вектор признаков
face_encoding = face_rec_model.compute_face_descriptor(rgb_frame, landmarks)
face_encoding_np = np.array(face_encoding)

# Ищем совпадения
best_match_name = "Неизвестный"
best_match_distance = float("inf")

for name, known_encoding in known_faces.items():
face_distance = distance.euclidean(known_encoding, face_encoding_np)

if face_distance < 0.6 and face_distance < best_match_distance:
best_match_name = name
best_match_distance = face_distance

# Рисуем результаты
x, y, w, h = face.left(), face.top(), face.width(), face.height()
cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
cv2.putText(frame, f"{best_match_name} ({best_match_distance:.2f})", 
(x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

# Отображаем результат
cv2.imshow('Video', frame)

# Выход по клавише 'q'
if cv2.waitKey(1) & 0xFF == ord('q'):
break

# Освобождаем ресурсы
video_capture.release()
cv2.destroyAllWindows()

# Запускаем распознавание в видео
recognize_faces_in_video()

import cv2
import speech_recognition as sr
import threading
import time
import numpy as np
import dlib
from scipy.spatial import distance

class MultimodalSystem:
def __init__(self):
# Инициализация распознавателя речи
self.speech_recognizer = sr.Recognizer()

# Инициализация детектора лиц
self.face_detector = dlib.get_frontal_face_detector()
self.predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
self.face_rec_model = dlib.face_recognition_model_v1("dlib_face_recognition_resnet_model_v1.dat")

# База данных известных лиц
self.known_faces = {}

# Состояние системы
self.is_running = False
self.current_speaker = "Неизвестный"

def load_known_face(self, name, image_path):
image = cv2.imread(image_path)
rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

faces = self.face_detector(rgb_image)
if not faces:
print(f"На изображении {image_path} не обнаружено лиц")
return False

landmarks = self.predictor(rgb_image, faces[0])
face_encoding = self.face_rec_model.compute_face_descriptor(rgb_image, landmarks)

self.known_faces[name] = np.array(face_encoding)
print(f"Лицо {name} успешно добавлено в базу")
return True

def speech_recognition_thread(self):
with sr.Microphone() as source:
self.speech_recognizer.adjust_for_ambient_noise(source, duration=1)

while self.is_running:
try:
print(f"{self.current_speaker} говорит...")
audio = self.speech_recognizer.listen(source, timeout=5, phrase_time_limit=5)

try:
text = self.speech_recognizer.recognize_google(audio, language="ru-RU")
print(f"{self.current_speaker}: {text}")

# Здесь можно добавить логику обработки команд
if "выход" in text.lower():
self.is_running = False

except sr.UnknownValueError:
print("Речь не распознана")
except sr.RequestError:
print("Ошибка сервиса распознавания речи")

except Exception as e:
print(f"Ошибка в потоке распознавания речи: {e}")

def face_recognition_thread(self):
video_capture = cv2.VideoCapture(0)

if not video_capture.isOpened():
print("Ошибка при открытии камеры")
self.is_running = False
return

while self.is_running:
ret, frame = video_capture.read()

if not ret:
print("Ошибка при захвате кадра")
break

rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
faces = self.face_detector(rgb_frame)

for face in faces:
landmarks = self.predictor(rgb_frame, face)
face_encoding = self.face_rec_model.compute_face_descriptor(rgb_frame, landmarks)
face_encoding_np = np.array(face_encoding)

best_match_name = "Неизвестный"
best_match_distance = 0.6 # Порог распознавания

for name, known_encoding in self.known_faces.items():
face_distance = distance.euclidean(known_encoding, face_encoding_np)

if face_distance < best_match_distance:
best_match_name = name
best_match_distance = face_distance

self.current_speaker = best_match_name

x, y, w, h = face.left(), face.top(), face.width(), face.height()
cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
cv2.putText(frame, f"{best_match_name}", 
(x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

cv2.imshow('Мультимодальная система', frame)

if cv2.waitKey(1) & 0xFF == ord('q'):
self.is_running = False

video_capture.release()
cv2.destroyAllWindows()

def start(self):
self.is_running = True

# Запускаем потоки распознавания
speech_thread = threading.Thread(target=self.speech_recognition_thread)
face_thread = threading.Thread(target=self.face_recognition_thread)

speech_thread.start()
face_thread.start()

# Ожидаем завершения потоков
speech_thread.join()
face_thread.join()

# Использование мультимодальной системы
system = MultimodalSystem()
system.load_known_face("Иван", "ivan.jpg")
system.load_known_face("Мария", "maria.jpg")
system.start()

from deepface import DeepFace

def analyze_emotions(image_path):
try:
analysis = DeepFace.analyze(image_path, actions=['emotion', 'age', 'gender', 'race'])
print(f"Эмоция: {analysis[0]['dominant_emotion']}")
print(f"Возраст: {analysis[0]['age']}")
print(f"Пол: {analysis[0]['gender']}")
return analysis
except Exception as e:
print(f"Ошибка при анализе эмоций: {e}")
return None

import speech_recognition as sr
import numpy as np
from scipy.io import wavfile
from scipy import signal

def preprocess_audio(audio_file):
# Загружаем аудиофайл
sample_rate, data = wavfile.read(audio_file)

# Конвертируем стерео в моно, если необходимо
if len(data.shape) > 1:
data = np.mean(data, axis=1)

# Применяем фильтр Баттерворта для устранения низкочастотного шума
b, a = signal.butter(5, 0.1, 'highpass')
filtered_data = signal.filtfilt(b, a, data)

# Нормализуем громкость
normalized_data = np.int16(filtered_data / np.max(np.abs(filtered_data)) * 32767)

# Сохраняем обработанный файл
output_file = "processed_" + audio_file
wavfile.write(output_file, sample_rate, normalized_data)

return output_file

def enhanced_speech_recognition(audio_file, language="ru-RU", context_phrases=None):
# Предобработка аудио
processed_file = preprocess_audio(audio_file)

recognizer = sr.Recognizer()

# Загружаем аудиофайл
with sr.AudioFile(processed_file) as source:
audio = recognizer.record(source)

# Задаем контекстные фразы для повышения точности
if context_phrases:
try:
return recognizer.recognize_sphinx(audio, language=language, keyword_entries=context_phrases)
except:
pass

# Пробуем разные API для распознавания
apis = [
(recognizer.recognize_google, {"language": language}),
(recognizer.recognize_sphinx, {"language": language}),
# Можно добавить другие API с соответствующими параметрами
]

for api_func, params in apis:
try:
return api_func(audio, **params)
except:
continue

# Если все методы не сработали
return "Не удалось распознать речь"

import cv2
import numpy as np
import time

def liveness_detection():
# Инициализируем детектор глаз и лица
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')

# Инициализируем камеру
cap = cv2.VideoCapture(0)

blink_count = 0
eye_status = True
previous_eye_status = True

print("Для проверки живости, пожалуйста, моргните 3 раза")

start_time = time.time()
timeout = 10 # Тайм-аут в секундах

while time.time() – start_time < timeout and blink_count < 3:
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

faces = face_cascade.detectMultiScale(gray, 1.3, 5)

for (x, y, w, h) in faces:
roi_gray = gray[y:y+h, x:x+w]
roi_color = frame[y:y+h, x:x+w]

# Обнаруживаем глаза
eyes = eye_cascade.detectMultiScale(roi_gray)

# Если глаза не обнаружены, считаем это морганием
eye_status = len(eyes) > 0

# Если статус глаз изменился с открытых на закрытые, засчитываем моргание
if previous_eye_status and not eye_status:
blink_count += 1
print(f"Моргание засчитано! ({blink_count}/3)")

previous_eye_status = eye_status

cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
cv2.putText(frame, f"Моргания: {blink_count}/3", (10, 30), 
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)

for (ex, ey, ew, eh) in eyes:
cv2.rectangle(roi_color, (ex, ey), (ex+ew, ey+eh), (0, 255, 0), 2)

cv2.imshow('Проверка живости', frame)

if cv2.waitKey(1) & 0xFF == ord('q'):
break

cap.release()
cv2.destroyAllWindows()

if blink_count >= 3:
print("Проверка живости пройдена!")
return True
else:
print("Проверка живости не пройдена.")
return False