Шаг -1

Теперь, когда мы изменили размеры нашего изображения, давайте импортируем cv2 и numpy , а также используем функцию CascadeClassifier из OpenCV, чтобы указать место, где мы сохранили Файл XML, haarcascade_frontalface_default.xml в нашем случае. Я скачал xml-файл на свой локальный компьютер и использовал путь к моей машине, но вы можете напрямую указать его местоположение github, если хотите.

 импорт cv2 
 импорт numpy как npface_classifier = cv2.CascadeClassifier ('/ haarcascade_frontalface_default.xml') 

Шаг 2

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

Обычно изображения, которые мы видим, имеют форму канала RGB (красный, зеленый, синий). Таким образом, когда OpenCV читает изображение RGB, оно обычно сохраняет изображение в канале BGR (синий, зеленый, красный).В целях распознавания изображений нам необходимо преобразовать этот канал BGR в серый канал. Причиной этого является то, что серый канал легко обрабатывается и требует меньших вычислительных затрат, поскольку содержит только 1 канал черно-белого цвета.

 grey = cv2.cvtColor (resized, cv2.COLOR_BGR2GRAY) 

Здесь параметрами функции cvtColor будут имя переменной изображения (в нашем случае с измененным размером ) и COLOR_BGR2GRAY.

Шаг 3

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

 face = face_classifier.detectMultiScale (grey, 1.0485258, 6) 

В этом фрагменте кода мы пытаемся использовать face_classifier , который является объектом, загруженным haarcascade_frontalface_default . xml, мы используем встроенную функцию с именем detectMultiScale.

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

Параметры, которые мы передадим этой функции:

1. Переменная серой шкалы — в нашем случае, серый цвет
2. scaleFactor — Параметр, указывающий, насколько уменьшается размер изображения
   при каждом масштабе изображения. По сути, масштабный коэффициент используется для создания вашей масштабной пирамиды. Более подробное объяснение: ваша модель имеет фиксированный размер, определенный во время обучения, который отображается в XML. Это означает, что этот размер лица определяется на изображении, если он присутствует. Однако, изменяя масштаб входного изображения, вы можете изменить размер большего лица на меньшее, что делает его обнаруживаемым алгоритмом.1.05 является хорошим возможным значением для этого, что означает, что вы используете небольшой шаг для изменения размера, то есть уменьшаете размер на 5%, вы увеличиваете вероятность совпадения размера с найденной моделью для обнаружения. Это также означает, что алгоритм работает медленнее, поскольку он более тщательный. Вы можете увеличить его до 1,4 для более быстрого обнаружения с риском пропустить некоторые лица в целом. В нашем случае я использовал 1.0485258 в качестве scaleFactor , поскольку он отлично работал для изображения, которое я использовал.
3. minNeighbors — Параметр, указывающий, сколько соседей должен иметь каждый прямоугольник-кандидат для его сохранения. Этот параметр повлияет на качество обнаруженных лиц. Чем выше значение, тем меньше обнаружений, но с более высоким качеством. 3 ~ 6 является хорошим значением для этого. В нашем случае я взял 6 в качестве minNeighbors , и это отлично сработало для изображения, которое я использовал.

Шаг 4

На вышеприведенном шаге функция detectMultiScale возвращает 4 значения — координату x, координату y, ширину (w) и высоту (h) обнаруженного элемента лица.Основываясь на этих 4 значениях, мы нарисуем прямоугольник вокруг лица.

, если грань есть (): 
 вывести («Лица не найдены») 
 для (x, y, w, h) в гранях: 
 cv2.rectangle (изменен размер, (x, y), (x + w, y) + h), (127,0255), 2) 
 cv2.imshow («Распознавание лиц», с измененным размером) 
 cv2.waitKey (0) 
 cv2.destroyAllWindows () 
 

Объединение всех четырех шагов вместе, ниже приведен код для него:

 import cv2 
 import numpy as npface_classifier = cv2.CascadeClassifier ('/ haarcascade_frontalface_default.xml ') grey = cv2.cvtColor (resized, cv2.COLOR_BGR2GRAY)' '' Наш классификатор возвращает ROI обнаруженного лица в виде кортежа, 
 В нем сохраняются верхняя левая координата и нижние правые координаты '''face = face_classifier. detectMultiScale (grey, 1.0485258, 6) '' 'Когда лица не обнаружены, face_classifier возвращает и пустой кортеж' '' 
, если face is (): 
 print ("лица не найдены") '' 'Мы выполняем итерацию по массиву лиц и нарисуйте прямоугольник над каждой гранью в гранях '' '
 для (x, y, w, h) в гранях: 
 cv2.прямоугольник (изменен размер, (x, y), (x + w, y + h), (127,0255), 2) 
 cv2.imshow («Обнаружение лица», изменен размер) 
 cv2.waitKey (0) 
 cv2. destroyAllWindows () 
 

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

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

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

В этой реализации есть несколько изменений, которые мы внесли по сравнению с Обнаружение лица код .

Шаг 1

Для обнаружения глаза мы также импортировали файл haarcascade_eye.xml .

 eye_classifier = cv2.CascadeClassifier ('/ haarcascade_eye.xml ') 

Шаг 2

После того, как мы получим координату x, координату y, ширину (w) и высоту (h) обнаруженного элемента лица с помощью функции detectMultiScale , мы создадим 2 массива numpy: roi_gray и roi_color. roi_gray — это массив пустышек, созданный с использованием переменной «серый». Причина, по которой мы создали это, состоит в том, чтобы передать эту версию серого канала в функцию detectMultiScale , извлекая при этом функции (ex, ey, ew, eh) глаз.

 для (x, y, w, h) в гранях: 
 cv2.rectangle (img, (x, y), (x + w, y + h), (127,0255), 2) 
 cv2.imshow ('img', img) 
 cv2.waitKey (0) 
 roi_gray = серый [y: y + h, x: x + w] 
 roi_color = img [y: y + h, x: x + w] 
 глаз = eye_classifier.detectMultiScale (roi_gray) 

Шаг 3

После того, как мы извлекли особенности глаза (ex, ey, ew, eh), мы пройдемся по ним и создадим прямоугольник, передав массив Numpy roi_color. Причиной передачи roi_color , а не roi_gray является roi_color — это массив для фактического изображения в масштабе RGB, тогда как roi_gray — это серая шкала изображения, которое мы использовали в нашем коде для более быстрой обработки при извлечении размеры / координаты изображения, а затем используйте эти размеры, чтобы передать его в исходный массив, который в нашем случае равен roi_color .

 для (ex, ey, ew, eh) в глазах: 
 cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (255,255,0), 2) 

Объединение всех шаги вместе:

 импорт numpy как np 
 импорт cv2 
 face_classifier = cv2.CascadeClassifier ('/ haarcascade_frontalface_default.xml') 
 eye_classifier = cv2.CascadeClassifier ('/ haarcascade_eye.xml' /imim.vim img) 
 group.jpg ') 
 grey = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) FaceS = Face_Classifier.detectMultiScale (серый, 1.05, 3) # Когда face_classifier возвращает и пустой кортеж 
, если face is (): 
 print, если не обнаружено ни одного лица («Лицо не найдено») для (x, y, w, h) в гранях: 
 cv2.прямоугольник (img, (x, y), (x + w, y + h), (127,0255), 2) 
 cv2.imshow ('img', img) 
 cv2.waitKey (0) 
 roi_gray = серый [y: y + h, x: x + w] 
 roi_color = img [y: y + h, x: x + w] 
 eyes = eye_classifier.detectMultiScale (roi_gray) 
 для (например, ey, ew, eh) в глазах: 
 cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (255,255,0), 2) 
 cv2.imshow ('img', img) 
 cv2.waitKey ( 0) 
 cv2.destroyAllWindows () 
 

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

3. Обнаружение транспортных средств по потоковому видео

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

Реализация здесь такая же, как и для обнаружения лиц, поэтому я не буду подробно объяснять весь процесс. Однако в коде есть несколько изменений.

Шаг 1

Для определения характеристик автомобиля нам нужно импортировать haarcascade_car.xml.

Используйте VideoCapture cv2 и сохраните значение в cap

Reading ( cap.read () ) из VideoCapture возвращает кортеж (ret, frame) . С первым пунктом вы проверяете, было ли чтение успешным, и если это было так, вы переходите к использованию возвращенного кадра .

 cap = cv2.VideoCapture ('/ vehicle.mp4') # Цикл после успешной загрузки видео 
, в то время как cap.isOpened (): 
 time.sleep (.05) 
 # Считать первый кадр 
 ret, frame = cap .read () 
 

Шаг 2

Теперь, когда у нас есть кортеж (ret, frame) , мы преобразуем изображение канала BGR в серый канал.Принимая во внимание то же самое, мы преобразуем изображение в шкалу серого и используем функцию классификатора detectMultiScale , чтобы извлечь координаты X, Y-координаты, ширину (W) и высоту (H), а шкала серого используется для повышения производительности. пропускная способность.

 серый = cv2.cvtColor (frame, cv2.COLOR_BGR2GRAY) 
 # Передать кадр в наш классификатор автомобилей 
 cars = car_classifier.detectMultiScale (серый, 1.1, 2) 
 

Шаг 3

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

 для (x, y, w, h) в автомобилях: 
 cv2.rectangle (frame, (x, y), (x + w, y + h), (0, 255, 255), 2) 

Ниже приведен сводный код для этого:

 время импорта 
 импорт numpy как np 
 импорт cv2 # Создайте наш классификатор тела 
 car_classifier = cv2.CascadeClassifier ('\ haarcascade_car.xml') # Инициируйте захват видео для видеофайла 
 cap = cv2 .VideoCapture ('/ vehicle.mp4') # Зацикливаться после успешной загрузки видео 
, пока cap.isOpened (): 
 time.sleep (.05) 
 # Считать первый кадр 
 ret, frame = cap.read () 
 grey = cv2.cvtColor (frame, cv2.COLOR_BGR2GRAY) 
 
 # Передать фрейм в наш классификатор автомобилей 
 cars = car_classifier.detectMultiScale (серый, 1.1, 2) 
 
 # Извлечь ограничивающие рамки для любых тел, определенных 
 для (x, y, w, h) в автомобилях: 
 cv2.rectangle (рамка, (x, y), (x + w, y + h), (0, 255, 255), 2) 
 cv2.imshow ( 'Cars', frame) 
, если cv2.waitKey (1) == 13: # 13 - это ключ ввода 
 breakcap.release () 
 cv2.destroyAllWindows () 

Теперь, когда у нас есть полный код, давайте проверим вывод для этого.

4. Обнаружение пешехода по потоковому видео

Реализация полностью идентична обнаружению транспортного средства. Единственная разница здесь будет в том, что мы будем использовать haarcascade_fullbody.xml , чтобы определить особенности тела пешехода.

Ниже приведен код для этого:

 import numpy as np 
 import cv2 # Создайте наш классификатор тела 
 body_classifier = cv2.CascadeClassifier ('\ haarcascade_fullbody.xml ') # Инициировать захват видео для видеофайла 
 cap = cv2.VideoCapture (' / moskva.mov ') # Цикл после успешной загрузки видео 
, а cap.isOpened (): 
 # Считать первый кадр 
 ret, frame = cap .read () 
 grey = cv2.cvtColor (frame, cv2.COLOR_BGR2GRAY) 
 # Передать фрейм в наш классификатор тел 
 body = body_classifier.detectMultiScale (серый, 1.1, 3) 
 # Извлечь ограничивающие рамки для любых тел, определенных 
 для ( x, y, w, h) в телах: 
 cv2.rectangle (frame, (x, y), (x + w, y + h), (0, 255, 255), 2) 
 cv2.imshow ('Пешеходы', фрейм) 
, если cv2.waitKey (1) == 13: # 13 - это ключ ввода 
 breakcap.release () 
 cv2.destroyAllWindows () 

Давайте проверим, как будет выглядеть вывод ниже видео:

Разделяемые мысли

Хотя классификатор haarcascade довольно полезен, у этого подхода есть несколько недостатков.

1. Наиболее сложной частью этого является точное указание значения параметра scaleFactor и minNeighbors функции detectMultiScale .Довольно часто встречаются сценарии, когда нам нужно настраивать оба параметра для каждого изображения отдельно, что является серьезным отключением, когда дело доходит до случая использования обнаружения изображения.
2. scaleFactor в основном используется для управления пирамидой изображения, которая, в свою очередь, используется для обнаружения объекта в различных масштабах изображения. Если scaleFactor слишком велик, то есть вероятность, что обнаружение изображения не будет точным, и мы будем пропускать объекты в масштабах, которые попадают под между слоями пирамиды.
3. Однако, если мы уменьшим значение scaleFactor , вы получите много слоев пирамид в одном масштабе изображения, что замедляет обнаружение и увеличивает количество ложных срабатываний.

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

Также, если вы хотите узнать о devops, пожалуйста, обратитесь на этот сайт.

Ссылки:

1. https: // docs.opencv.org/3.4/db/d28/tutorial_cascade_classifier.html
2. https://www.pyimagesearch.com/2016/06/20/detecting-cats-in-images-with-opencv/
3. https: // github .com / krishnaik06 / Computer-Vision-Tutorial

Глубокое изучение каскада Хаара Объяснение

Хорошо! Здесь мы начинаем развлекаться! Концепция каскада Хаара и то, как он используется в реальном мире, не может не удивить. Так что же это?

Каскад Хаара

Каскад Хаара — это алгоритм обнаружения объектов машинного обучения, используемый для идентификации объектов на изображении или видео и основанный на концепции функций , предложенной Полом Виолой и Майклом Джонсом в их статье «Быстрый объект» Обнаружение с использованием расширенного каскада простых функций «в 2001 году.

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

Алгоритм состоит из четырех этапов:

1. Выбор функций Хаара
2. Создание интегральных изображений
3. Обучение Adaboost
4. Каскадные классификаторы

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

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

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

Встроенные изображения используются, чтобы сделать это очень быстро.

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

Так как же выбрать лучшие функции из 160000+ функций? Это достигается с помощью концепции Adaboost , которая одновременно выбирает лучшие функции и обучает классификаторы, которые их используют.Этот алгоритм создает «сильный» классификатор как линейную комбинацию взвешенных простых «слабых» классификаторов. Процесс заключается в следующем.

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

Каскадный классификатор

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

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

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

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

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

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

Видео ниже показывает это в действии.

Каскад Хаара — Определение лица в действии

Если картинка стоит тысячи слов, это будет миллион слов. Вот где все это объединяется. Ааааа момент.

Это простое видео помогло мне понять, как работает этот алгоритм. Вот некоторые наблюдения:

• Обратите внимание, как алгоритм систематически перемещает окно по изображению, применяя функции Хаара, когда он пытается определить лицо. Это изображено зелеными прямоугольниками.
• Обратите внимание, что под красным граничным квадратом мы видим, как классификатор выполняет этапы, быстро отбрасывая оконные рамы, которые явно не совпадают (этапы 1-25)
• Справа от этапа мы видим, насколько хорошо он выполнил идентификацию лица ,
• Обратите внимание, что по мере приближения к определению лица число этапов увеличивается до 20 с. (около 1 минуты). Это демонстрирует каскадный эффект, когда ранние этапы отбрасывают входные данные, поскольку он определил их как не относящиеся к делу.Поскольку это становится ближе к поиску лица, это обращает более пристальное внимание.

Дайте мне знать, если у вас есть какие-либо вопросы или комментарии ниже.

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

Следующие шаги

Я не знаю о вас, но я считаю, что лучший способ понять что-то — это сделать это.Концептуально у нас теперь есть идея, как работает машинное обучение обнаружению объектов Haar Cascade. Теперь давайте создадим собственный детектор объектов в реальном мире, обучим его и увидим его в действии. У меня есть действительно классный пример для нас! Нажмите на кнопку ниже.

Ссылки

1. Википедия, Википедия. «AdaBoost.» Википедия , Фонд Викимедиа, 13 января 2018 г., en.wikipedia.org/wiki/AdaBoost.
2. Документы, OpenCV. «Обнаружение лица с использованием каскадов Хаара». OpenCV: обнаружение лица с использованием каскадов Хаара , 4 августа.2017, docs.opencv.org/3.3.0/d7/d8b/tutorial_py_face_detection.html.
3. Википедия, Википедия. «Среда обнаружения объекта Виола – Джонса». Википедия , Фонд Викимедиа, 4 ноября. 2017, en.wikipedia.org/wiki/Viola–Jones_object_detection_framework.
4. Википедия, Википедия. «Каскадные классификаторы». Википедия , Фонд Викимедиа, 15 октября. 2013, en.wikipedia.org/wiki/Cascading_classifiers.
5. Математика, Математика. «Обучить детектор каскадных объектов» Mathworks , 2017, www.mathworks.com/help/vision/ug/train-a-cascade-object-detector.html.

Страница не найдена · GitHub Pages

Файл не найден

Сайт настроен по этому адресу не содержать запрошенный файл.

Если это ваш сайт, убедитесь, что регистр имени файла соответствует URL.
Для корневых URL (например, http://example.com/ ) вы должны предоставить index.html файл.

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