Как сделать распознавание лиц на python
Перейти к содержимому

Как сделать распознавание лиц на python

  • автор:

Находим лица в картинке с веб-камеры

Сегодня сделаем модную штуку в Python — научимся находить лица в веб-камере. Потом научимся делать то же самое на картинах, а затем на основе этого сделаем много разного и интересного.

Вот что нужно для начала знать о распознавании лиц:

  • Для распознавания лица компьютер должен получить изображение — через камеру или готовый файл.
  • Компьютер использует особый алгоритм, который разбивает изображение на прямоугольники.
  • С помощью этих прямоугольников алгоритм пытается найти на картинке знакомые ему переходы между светлыми и тёмными областями.
  • Если в одном месте программа находит много таких совпадений, то, скорее всего, это лицо человека.
  • Чтобы программистам каждый раз не писать свой код распознавания с нуля, сделали специальную библиотеку компьютерного зрения — cv2. Если в неё загрузить заранее подготовленные параметры лиц, она сможет распознавать их намного точнее.
  • С помощью этой библиотеки можно находить на картинке не только лица, но и другие предметы — для этого нужно использовать дополнительные библиотеки либо обучать систему самому.

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

Сегодня сделаем модную штуку в Python — научимся находить лица в веб-камере

Логика проекта

Будем делать так:

  1. Установим и подключим библиотеку cv2.
  2. Получим изображение с камеры и выведем его в отдельном окне.
  3. Обучим библиотеку находить лица.
  4. Напишем функцию выделения лиц на изображении.
  5. Объединим всё вместе и получим выделение лица с камеры в режиме реального времени.

Для проекта нам понадобится Python — это идеальный язык для работы с нейросетями и компьютерным зрением.

Устанавливаем cv2

Для установки библиотеки запустим терминал или VS Code и выполним такую команду:

pip install opencv-python

Теперь убедимся, что это сработало: создаём новый Python-файл и пишем в нём команду:

# подключаем библиотеку компьютерного зрения import cv2

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

Получаем изображение с камеры

По умолчанию библиотека работает с веб-камерой, которая в системе установлена первой (и часто — единственной). Так как нумерация в программировании почти всегда начинается с нуля, нам нужно обратиться к нулевому устройству видеозахвата.

В современных операционных системах в целях безопасности доступ к камере отключён для внешних скриптов, поэтому при первом запуске у нас могут спросить: разрешить доступ к камере или нет? Выбираем вариант «Да, разрешить»:

Находим лица в картинке с веб-камеры

После этого делаем так: пока не нажата любая клавиша — выводим окошко с изображением. Но может случиться так, что доступ к камере есть, а с самой камерой что-то не так — нет картинки, например. В этом случае нет смысла пытаться определить лица — лучше сразу прекратить работу. Для этого мы проверяем параметр hasFrame — он как раз отвечает за то, есть картинка или нет.

Добавляем этот код в файл, сохраняем и запускаем скрипт:

# получаем видео с камеры video=cv2.VideoCapture(0) # пока не нажата любая клавиша — выполняем цикл while cv2.waitKey(1)

Появилась картинка — значит, мы на верном пути

Запускаем нейросеть для определения лиц

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

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

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

Теперь всё готово для создания нейросети по определению лица на изображении:

# загружаем веса для распознавания лиц faceProto="opencv_face_detector.pbtxt" # и конфигурацию самой нейросети — слои и связи нейронов faceModel="opencv_face_detector_uint8.pb" # запускаем нейросеть по распознаванию лиц faceNet=cv2.dnn.readNet(faceModel,faceProto)

Пишем функцию определения лиц

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

У функции на входе будет три параметра:

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

Кадр — это условный скриншот того, что видит камера. В секунду камера может обрабатывать от 15 до 60 кадров — это зависит от самой камеры и настроек операционной системы.

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

Модель определения — это алгоритм, по которому компьютер поймёт, что перед нами именно лицо. Его мы как раз сделали на предыдущем этапе.

Выполним предварительную работу внутри функции:

  • получим размеры кадра;
  • превратим кадр в бинарный объект с помощью специального алгоритма;
  • прогоним объект через модель распознавания;
  • создадим массив для рамок — там будут храниться координаты рамок для всех найденных лиц.
# функция определения лиц def highlightFace(net, frame, conf_threshold=0.7): # делаем копию текущего кадра frameOpencvDnn=frame.copy() # высота и ширина кадра frameHeight=frameOpencvDnn.shape[0] frameWidth=frameOpencvDnn.shape[1] # преобразуем картинку в двоичный пиксельный объект blob=cv2.dnn.blobFromImage(frameOpencvDnn, 1.0, (300, 300), [104, 117, 123], True, False) # устанавливаем этот объект как входной параметр для нейросети net.setInput(blob) # выполняем прямой проход для распознавания лиц detections=net.forward() # переменная для рамок вокруг лица faceBoxes=[]

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

Ещё мы сразу записываем координаты найденного блока с лицом в отдельный массив — он нам пригодится для отрисовки рамок вокруг лиц на картинке.

Результат работы функции — это сам кадр и массив с координатами рамок вокруг лиц.

 # перебираем все блоки после распознавания for i in range(detections.shape[2]): # получаем результат вычислений для очередного элемента confidence=detections[0,0,i,2] # если результат превышает порог срабатывания — это лицо if confidence>conf_threshold: # формируем координаты рамки x1=int(detections[0,0,i,3]*frameWidth) y1=int(detections[0,0,i,4]*frameHeight) x2=int(detections[0,0,i,5]*frameWidth) y2=int(detections[0,0,i,6]*frameHeight) # добавляем их в общую переменную faceBoxes.append([x1,y1,x2,y2]) # рисуем рамку на кадре cv2.rectangle(frameOpencvDnn, (x1,y1), (x2,y2), (0,255,0), int(round(frameHeight/150)), 8) # возвращаем кадр с рамками return frameOpencvDnn,faceBoxes

Собираем всё вместе и запускаем скрипт

Единственное, что осталось сделать, — добавить в основной цикл вызов функции для определения лица и сделать проверку, когда определённых лиц нет:

# распознаём лица в кадре resultImg,faceBoxes=highlightFace(faceNet,frame) # если лиц нет if not faceBoxes: # выводим в консоли, что лицо не найдено print("Лица не распознаны")

Теперь скрипт можно запускать и проверять — на каком расстоянии перестанет работать компьютерное зрение и сколько человек одновременно система сможет распознать.

Находим лица в картинке с веб-камеры

Готовый код

# подключаем библиотеку компьютерного зрения import cv2 # функция определения лиц def highlightFace(net, frame, conf_threshold=0.7): # делаем копию текущего кадра frameOpencvDnn=frame.copy() # высота и ширина кадра frameHeight=frameOpencvDnn.shape[0] frameWidth=frameOpencvDnn.shape[1] # преобразуем картинку в двоичный пиксельный объект blob=cv2.dnn.blobFromImage(frameOpencvDnn, 1.0, (300, 300), [104, 117, 123], True, False) # устанавливаем этот объект как входной параметр для нейросети net.setInput(blob) # выполняем прямой проход для распознавания лиц detections=net.forward() # переменная для рамок вокруг лица faceBoxes=[] # перебираем все блоки после распознавания for i in range(detections.shape[2]): # получаем результат вычислений для очередного элемента confidence=detections[0,0,i,2] # если результат превышает порог срабатывания — это лицо if confidence>conf_threshold: # формируем координаты рамки x1=int(detections[0,0,i,3]*frameWidth) y1=int(detections[0,0,i,4]*frameHeight) x2=int(detections[0,0,i,5]*frameWidth) y2=int(detections[0,0,i,6]*frameHeight) # добавляем их в общую переменную faceBoxes.append([x1,y1,x2,y2]) # рисуем рамку на кадре cv2.rectangle(frameOpencvDnn, (x1,y1), (x2,y2), (0,255,0), int(round(frameHeight/150)), 8) # возвращаем кадр с рамками return frameOpencvDnn,faceBoxes # загружаем веса для распознавания лиц faceProto="opencv_face_detector.pbtxt" # и конфигурацию самой нейросети — слои и связи нейронов faceModel="opencv_face_detector_uint8.pb" # запускаем нейросеть по распознаванию лиц faceNet=cv2.dnn.readNet(faceModel,faceProto) # получаем видео с камеры video=cv2.VideoCapture(0) # пока не нажата любая клавиша — выполняем цикл while cv2.waitKey(1)

Что дальше

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

Нейросети победили. Победите нейросети

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

Нейросети победили. Победите нейросети Нейросети победили. Победите нейросети Нейросети победили. Победите нейросети Нейросети победили. Победите нейросети

Получите ИТ-профессию

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

Урок #7 – Распознавание лиц на Python + OpenCV

Урок #7 – Распознавание лиц на Python + OpenCV

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

Видеоурок

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

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

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

Найти все натренированные модели OpenCV можно по этой ссылке .

Тренировка нейронной системы

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

Весь код будет доступен после подписки на проект!

Распознавание лиц при помощи Python и OpenCV

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

Что такое обнаружение лиц?

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

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

Существует много алгоритмов обнаружения лиц. Одним из старейших является алгоритм Виолы-Джонса. Он был предложен в 2001 году и применяется по сей день. Чуть позже мы тоже им воспользуемся. После прочтения данной статьи вы можете изучить его более подробно.

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

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

Что такое распознавание лиц?

Итак, в создании алгоритмов обнаружения лиц мы (люди) преуспели. А можно ли также распознавать, чьи это лица?

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

Итак, давайте разберемся, как мы распознаем лица при помощи глубокого обучения. Для начала мы производим преобразование, или, иными словами, эмбеддинг (embedding), изображения лица в числовой вектор. Это также называется глубоким метрическим обучением.

Для облегчения понимания давайте разобьем весь процесс на три простых шага:

Обнаружение лиц

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

Извлечение признаков

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

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

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

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

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

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

Здесь мы не будем заниматься обучением подобной сети. Это требует значительных вычислительных мощностей и большого объема размеченных данных. Вместо этого мы используем уже предобученную Дэвисом Кингом нейронную сеть. Она обучалась приблизительно на 3000000 изображений. Эта сеть выдает вектор длиной 128 чисел, который и определяет основные черты лица.

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

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

Сравнение лиц

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

Итак, мы передали в сеть две фотографии, одна Владимира Путина, другая Джорджа Буша. Для изображений Буша у нас были вектора (эмбеддинги), а для Путина ничего не было. Таким образом, когда мы сравнили эмбеддинг нового изображения Буша, он был близок с уже имеющимися векторам,и и мы распознали его. А вот изображений Путина в нашей базе не было, поэтому распознать его не удалось.

Что такое OpenCV?

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

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

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

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

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

OpenCV — это библиотека с открытым программным кодом. Она поддерживает различные языки программирования, например R и Python. Работать она может на многих платформах, в частности — на Windows, Linux и MacOS.

Основные преимущества OpenCV :

  • имеет открытый программный код и абсолютно бесплатна
  • написана на C/C++ и в сравнении с другими библиотеками работает быстрее
  • не требует много памяти и хорошо работает при небольшом объеме RAM
  • поддерживает большинство операционных систем, в том числе Windows, Linux и MacOS.

Установка

Здесь мы будем рассматривать установку OpenCV только для Python. Мы можем установить ее при помощи менеджеров pip или conda (в случае, если у нас установлен пакет Anaconda).

1. При помощи pip

При помощи pip процесс установки может быть выполнен с использованием следующей команды:

pip install opencv-python
2. Anaconda

Если вы используете Anaconda, то выполните следующую команду в окружении Anaconda:

conda install -c conda-forge opencv

Распознавание лиц с использованием Python

В этой части мы реализуем распознавание лиц при помощи Python и OpenCV. Для начала посмотрим, какие библиотеки нам потребуются и как их установить:

  • OpenCV
  • dlib
  • Face_recognition

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

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

Библиотека face_recognition , созданная Адамом Гейтгеем, включает в себя функции распознавания лиц dlib и является по сути надстройкой над ней. С ней очень легко работать, и мы будем ее использовать в нашем коде. Имейте ввиду, что ее нужно устанавливать после библиотеки dlib .

Для установки OpenCV наберите в командной строке:

pip install opencv-python

Мы перепробовали множество способов установки dlib под WIndows и простейший способ это сделать — при помощи Anaconda. Поэтому для начала установите Anaconda (вот здесь подробно рассказано, как это делается). Затем введите в терминале следующую команду:

conda install -c conda-forge dlib

Далее, для установки библиотеки face_recognition наберите в командной строке следующее:

pip install face_recognition

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

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

Извлечение признаков лица

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

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

from imutils import paths import face_recognition import pickle import cv2 import os # в директории Images хранятся папки со всеми изображениями imagePaths = list(paths.list_images('Images')) knownEncodings = [] knownNames = [] # перебираем все папки с изображениями for (i, imagePath) in enumerate(imagePaths): # извлекаем имя человека из названия папки name = imagePath.split(os.path.sep)[-2] # загружаем изображение и конвертируем его из BGR (OpenCV ordering) # в dlib ordering (RGB) image = cv2.imread(imagePath) rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) #используем библиотеку Face_recognition для обнаружения лиц boxes = face_recognition.face_locations(rgb,model='hog') # вычисляем эмбеддинги для каждого лица encodings = face_recognition.face_encodings(rgb, boxes) # loop over the encodings for encoding in encodings: knownEncodings.append(encoding) knownNames.append(name) # сохраним эмбеддинги вместе с их именами в формате словаря data = # для сохранения данных в файл используем метод pickle f = open("face_enc", "wb") f.write(pickle.dumps(data)) f.close()

Сейчас мы сохранили все эмбеддинги в файл под названием face_enc . Теперь мы можем их использовать для распознавания лиц на изображениях или во время видеострима с веб-камеры.

Распознавание лиц во время прямой трансляции веб-камеры

Вот код для распознавания лиц из прямой трансляции веб-камеры:

import face_recognition import imutils import pickle import time import cv2 import os # find path of xml file containing haarcascade file cascPathface = os.path.dirname( cv2.__file__) + "/data/haarcascade_frontalface_alt2.xml" # load the harcaascade in the cascade classifier faceCascade = cv2.CascadeClassifier(cascPathface) # load the known faces and embeddings saved in last file data = pickle.loads(open('face_enc', "rb").read()) print("Streaming started") video_capture = cv2.VideoCapture(0) # loop over frames from the video file stream while True: # grab the frame from the threaded video stream ret, frame = video_capture.read() gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(60, 60), flags=cv2.CASCADE_SCALE_IMAGE) # convert the input frame from BGR to RGB rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # the facial embeddings for face in input encodings = face_recognition.face_encodings(rgb) names = [] # loop over the facial embeddings incase # we have multiple embeddings for multiple fcaes for encoding in encodings: # Compare encodings with encodings in data["encodings"] # Matches contain array with boolean values and True for the embeddings it matches closely # and False for rest matches = face_recognition.compare_faces(data["encodings"], encoding) # set name =inknown if no encoding matches name = "Unknown" # check to see if we have found a match if True in matches: #Find positions at which we get True and store them matchedIdxs = [i for (i, b) in enumerate(matches) if b] counts = <> # loop over the matched indexes and maintain a count for # each recognized face face for i in matchedIdxs: # Check the names at respective indexes we stored in matchedIdxs name = data["names"][i] # increase count for the name we got counts[name] = counts.get(name, 0) + 1 # set name which has highest count name = max(counts, key=counts.get) # update the list of names names.append(name) # loop over the recognized faces for ((x, y, w, h), name) in zip(faces, names): # rescale the face coordinates # draw the predicted face name on the image cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) cv2.putText(frame, name, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 2) cv2.imshow("Frame", frame) if cv2.waitKey(1) & 0xFF == ord('q'): break video_capture.release() cv2.destroyAllWindows()

В данном примере для обнаружения лиц использовался метод cv2.CascadeClassifier() из библиотеки OpenCV. Но вы с таким же успехом можете пользоваться и методом face_recognition.face_locations() , как мы уже делали в предыдущем примере.

Распознавание лиц на изображениях

Код для обнаружения и распознавания лиц на изображениях почти аналогичен тому, что вы видели выше. Убедитесь в этом сами:

import face_recognition import imutils import pickle import time import cv2 import os # find path of xml file containing haarcascade file cascPathface = os.path.dirname( cv2.__file__) + "/data/haarcascade_frontalface_alt2.xml" # load the harcaascade in the cascade classifier faceCascade = cv2.CascadeClassifier(cascPathface) # load the known faces and embeddings saved in last file data = pickle.loads(open('face_enc', "rb").read()) # Find path to the image you want to detect face and pass it here image = cv2.imread(Path-to-img) rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # convert image to Greyscale for haarcascade gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(60, 60), flags=cv2.CASCADE_SCALE_IMAGE) # the facial embeddings for face in input encodings = face_recognition.face_encodings(rgb) names = [] # loop over the facial embeddings incase # we have multiple embeddings for multiple fcaes for encoding in encodings: # Compare encodings with encodings in data["encodings"] # Matches contain array with boolean values and True for the embeddings it matches closely # and False for rest matches = face_recognition.compare_faces(data["encodings"], encoding) # set name =inknown if no encoding matches name = "Unknown" # check to see if we have found a match if True in matches: # Find positions at which we get True and store them matchedIdxs = [i for (i, b) in enumerate(matches) if b] counts = <> # loop over the matched indexes and maintain a count for # each recognized face face for i in matchedIdxs: # Check the names at respective indexes we stored in matchedIdxs name = data["names"][i] # increase count for the name we got counts[name] = counts.get(name, 0) + 1 # set name which has highest count name = max(counts, key=counts.get) # update the list of names names.append(name) # loop over the recognized faces for ((x, y, w, h), name) in zip(faces, names): # rescale the face coordinates # draw the predicted face name on the image cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2) cv2.putText(image, name, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 2) cv2.imshow("Frame", image) cv2.waitKey(0)

Результат:

На этом наша статья подошла к концу. Мы надеемся, что вы получили общее представление о задачах распознавания лиц и способах их решения.

Распознавание лиц на python c отправкой в телеграмм или как защититься от недоброжелателей

Что за программы? Представим такую ситуацию, вам в инстаграме угрожает не очень умный человек и каким то ЧУДЕСНЫМ образом он узнал ваш адрес. К вашему счастью он сглупил и оказалось, что он ставил в ленту свое фото с лицом. Вы боитесь этого человека. Что можно сделать? Определенно не писать скрипт по распознаванию лица, но мы тут с вами Pyhton-исты. Так вот, у нас будет папка (назовем ее img) в которой будет лицо нашего злоумышленника (я не зря говорил, что он ставил фото),скрипт будет получать видео с камеры (которую можно повесить у двери своего дома). Если вдруг на видео будет замечено человеческое лицо, оно будет сверяться на схожесть с лицом нашего злоумышленника (по фотке с лицом которое в папке img). Если лица совпадают, то это значит, что у вашей двери стоит тот самый злоумышленник, в такой ситуации у нас просто будет выводиться что то в консоль. Вы же можете сделать к примеру телеграмм бота, который при такой ситуации будет вам писать.

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

Для программ нам понадобятся модули opencv, face recognition.

OpenCV качайте так pip install opencv-python . Самая сложная часть для меня была в установке face-recognition, так как при его установке вылезала ошибка. Однако у вас может ее не быть. Попробуйте скачать этот модуль. В консоли напишите: pip install dlib & pip install face-recognition

Если же появилась, необходимо установить Visual Studio и там выбрать и установить Python и C++. Может сейчас не понятно, но скачав Visual Studio до вас дойдет о чем я. После установки VisualStudio можете смело качать этот модуль. Так же необходимо скачать натренированную нейронную модель. Вот. Я сохранил это все дело как faces.xml

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

import cv2 #Импортировали модуль opencv path_to_img = input("Введите путь до картинки (полное название файла, с форматом)>>> ") #Получаем путь к картинке из которой надо обрезать лицо img = cv2.imread(path_to_img) #Методом imread мы как бы читаем наше фото, после этого можем производить манипуляции над ним face_recog = cv2.CascadeClassifier('faces.xml') #Методом CascadeClassifier мы подключаем уже натренированную нейронную модель. face_result = face_recog.detectMultiScale(img, scaleFactor=2, minNeighbors=3) #Метод detectMultiScale выполняет поиск лица на фото которые мы указали в качестве первого аргумента #Аргумент scaleFactor это как бы шаг масштабирования (насколько большое лицо) #Аргумент minNeighbors это что то вроде указания о том, сколько лиц может быть рядом #Значение этим аргументам я взял с воздуха, но все же это работает #Вы можете поиграться с ними, главное не ставьте scaleFactor=1 так как будет ошибка if len(face_result) != 0: #Функция, выполнение которой мы записали в face_result (detectMultiScale), возвращает список, если он пуст, значит лиц на фото нет for index, (x,y,w,h) in enumerate(face_result): #Мы проходимся по всем элементам списка, и получаем позицию x,y и ширину с высотой(w,h) img = img[x:y+h] #Тут думаю все понятно, мы обрезаем картинку (она у нас как список с цветами) с точки x до точки y+h cv2.imwrite(f'images/to_recog/practice/.jpg', img) #Этот метод записывает получившуюся картинку по опр. пути, принимает путь и само изображение cv2.imshow("Result", img) #Этот метод выводит результат на экран. Первый аргумент - что то по типу комментария к картинке, второй - сама картинка cv2.waitKey(0) #От этого, зависит какое кол-во времени наша картинка будет отображаться на экране. Если передаем 0 то будет отображаться пока не закроем(бесконечно)ся 

И так. Запустим ее и передадим фото Рами Малека

БылоСтало

Как видим все круто и не очень трудно. Главное понять принцип. Давайте теперь займемся главной (первой) программой которая будет сравнивать лица. Она немножко труднее, но не бойтесь, все равно будет просто.

import cv2 import face_recognition import os #Импортируем все модули cap = cv2.VideoCapture(0) #Методом VideoCapture мы получаем видео, тут можно указать путь к mp4 файлу и прочитать его #Указав 0 мы получаем видео с ВЕБ КАМЕРЫ image_to_recognition = face_recognition.load_image_file('images/to_recog/practice/0.jpg') #Теперь начинаем работать с face_recognition, метод load_image_file получает изображение #В данном случае то фото рами малека которые мы обрезали второй программой image_enc = face_recognition.face_encodings(image_to_recognition)[0] #Тут методом face_encodings мы получаем КОДИРОВКУ ЛИЦА рами малека. #Просто у каждого фото с лицом (да и не только) есть КОДИРОВКА. #Если у нас есть 2 фото с лицами и если их кодировки совпадают, значит на фото один и тот же человвек recognizer_cc = cv2.CascadeClassifier('faces.xml') #Про это уже говорил #Любое видео, это быстро меняющиеся картинки, от того и создается эффект анимации #Здесь тот же принцип, в бесконечном цикле мы очень быстро меняем изображения и получаем видео while True: success,img = cap.read() #Получаем изображение которое будем быстро показывать, если изображение не получено success будет равен False recognize = recognizer_cc.detectMultiScale(img, scaleFactor=2, minNeighbors=3) #Про это уже говорил if len(recognize) != 0: #Если на фото есть лицо, делаем то, что ниже print("Лицо нашел") unknown_face = face_recognition.face_encodings(img) #Получем кодировку неизвестного лица (лица которое на видео) compare = face_recognition.compare_faces([unknown_face], image_enc) #Сравниваем две кодировки (кодировку рами малека и кодировку неизвестного лица) #Первый параметр надо передать как список (за это и обернули в []) #Второй это кодировка рами малека (этот аргумент передаем просто) if compare == True: #Если мы зашли сюда, значит лица одинаковые print('Рами приблизился к вашему дому!') else: print('Все ок.') 

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

Не судите строго, это моя первая статья, если есть какие то ошибки напишите об этом ниже 🙂

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *