Алговики - Вклад [ru]

Участник:Bagnikita/Face Recognition

2016-11-02T08:53:19Z

Bagnikita:

{{Assignment}}
{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки, например, NVIDIA cuDNN<ref>https://developer.nvidia.com/cudnn</ref>) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как JointBayesian<ref>Chen D. et al. Bayesian face revisited: A joint formulation //European Conference on Computer Vision. – Springer Berlin Heidelberg, 2012. – С. 566-579.</ref>. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

[[Файл:Facerecognition-graph.png|thumb|center|700px|Рисунок 0. Граф параллельного алгоритма]]

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

Построение биометрических шаблонов выполнено при помощи библиотеки распознавания лиц Tevian FaceSDK<ref>http://tevian.ru/product/facesdk</ref>. В этом разделе приводится эффективность параллельной реализации сравнения изображени лица с некоторой базой лиц.

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

== Литература ==

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-11-02T08:52:27Z

Bagnikita: /* Информационный граф */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки, например, NVIDIA cuDNN<ref>https://developer.nvidia.com/cudnn</ref>) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как JointBayesian<ref>Chen D. et al. Bayesian face revisited: A joint formulation //European Conference on Computer Vision. – Springer Berlin Heidelberg, 2012. – С. 566-579.</ref>. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

[[Файл:Facerecognition-graph.png|thumb|center|700px|Рисунок 0. Граф параллельного алгоритма]]

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

Построение биометрических шаблонов выполнено при помощи библиотеки распознавания лиц Tevian FaceSDK<ref>http://tevian.ru/product/facesdk</ref>. В этом разделе приводится эффективность параллельной реализации сравнения изображени лица с некоторой базой лиц.

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

== Литература ==

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-11-02T08:52:18Z

Bagnikita: /* Информационный граф */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки, например, NVIDIA cuDNN<ref>https://developer.nvidia.com/cudnn</ref>) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как JointBayesian<ref>Chen D. et al. Bayesian face revisited: A joint formulation //European Conference on Computer Vision. – Springer Berlin Heidelberg, 2012. – С. 566-579.</ref>. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

[[Файл:Facerecognition-1raph.png|thumb|center|700px|Рисунок 0. Граф параллельного алгоритма]]

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

Построение биометрических шаблонов выполнено при помощи библиотеки распознавания лиц Tevian FaceSDK<ref>http://tevian.ru/product/facesdk</ref>. В этом разделе приводится эффективность параллельной реализации сравнения изображени лица с некоторой базой лиц.

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

== Литература ==

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-11-02T08:50:41Z

Bagnikita: /* Информационный граф */

Участник:Bagnikita/Face Recognition

2016-11-02T08:40:31Z

Bagnikita:

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки, например, NVIDIA cuDNN<ref>https://developer.nvidia.com/cudnn</ref>) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как JointBayesian<ref>Chen D. et al. Bayesian face revisited: A joint formulation //European Conference on Computer Vision. – Springer Berlin Heidelberg, 2012. – С. 566-579.</ref>. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

TODO: сгенерировать картинку в graphviz

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

Построение биометрических шаблонов выполнено при помощи библиотеки распознавания лиц Tevian FaceSDK<ref>http://tevian.ru/product/facesdk</ref>. В этом разделе приводится эффективность параллельной реализации сравнения изображени лица с некоторой базой лиц.

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

== Литература ==

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-11-02T08:39:58Z

Bagnikita: /* Программная реализация алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки, например, NVIDIA cuDNN<ref>https://developer.nvidia.com/cudnn</ref>) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как JointBayesian<ref>Chen D. et al. Bayesian face revisited: A joint formulation //European Conference on Computer Vision. – Springer Berlin Heidelberg, 2012. – С. 566-579.</ref>. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

TODO: сгенерировать картинку в graphviz

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

Построение биометрических шаблонов выполнено при помощи библиотеки распознавания лиц Tevian FaceSDK<ref>http://tevian.ru/product/facesdk</ref>. В этом разделе приводится эффективность параллельной реализации сравнения изображени лица с некоторой базой лиц.

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-11-02T08:39:45Z

Bagnikita: /* Программная реализация алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки, например, NVIDIA cuDNN<ref>https://developer.nvidia.com/cudnn</ref>) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как JointBayesian<ref>Chen D. et al. Bayesian face revisited: A joint formulation //European Conference on Computer Vision. – Springer Berlin Heidelberg, 2012. – С. 566-579.</ref>. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

TODO: сгенерировать картинку в graphviz

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

Построение биометрических шаблонов выполнено при помощи библиотеки распознавания лиц FaceSDK<ref>http://tevian.ru/product/facesdk</ref>. В этом разделе приводится эффективность параллельной реализации сравнения изображени лица с некоторой базой лиц.

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-11-02T08:39:02Z

Bagnikita: /* Сравнение биометрических шаблонов */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки, например, NVIDIA cuDNN<ref>https://developer.nvidia.com/cudnn</ref>) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как JointBayesian<ref>Chen D. et al. Bayesian face revisited: A joint formulation //European Conference on Computer Vision. – Springer Berlin Heidelberg, 2012. – С. 566-579.</ref>. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

TODO: сгенерировать картинку в graphviz

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-11-02T08:38:13Z

Bagnikita: /* Обучение сверточной нейронной сети */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки, например, NVIDIA cuDNN<ref>https://developer.nvidia.com/cudnn</ref>) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

TODO: сгенерировать картинку в graphviz

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-11-02T08:37:07Z

Bagnikita: /* Общее описание алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

TODO: сгенерировать картинку в graphviz

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T23:19:09Z

Bagnikita: /* Масштабируемость алгоритма и его реализации */

{{Assignment}}
{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

TODO: сгенерировать картинку в graphviz

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T23:18:49Z

Bagnikita: /* Исследование влияния HyperThreading на работу алгоритма */

{{Assignment}}
{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

TODO: сгенерировать картинку в graphviz

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:46:23Z

Bagnikita: /* Информационный граф */

{{Assignment}}
{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

TODO: сгенерировать картинку в graphviz

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:46:02Z

Bagnikita: /* Информационный граф */

{{Assignment}}
{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:34:29Z

Bagnikita: /* Cортировка по убыванию метрики сходства двух изображений */

{{Assignment}}
{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:33:37Z

Bagnikita:

{{Assignment}}
{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:30:11Z

Bagnikita: /* Макроструктура алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:29:54Z

Bagnikita: /* Макроструктура алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:25:02Z

Bagnikita: /* Выводы для классов архитектур */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:21:56Z

Bagnikita: /* Программная реализация алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный метод должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов.

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:17:20Z

Bagnikita: /* Исследование влияния HyperThreading на работу алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-matcher.png|1280px]]

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-reduce.png|1280px]]

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-overall.png|1280px]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный метод должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов.

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:15:21Z

Bagnikita: /* Динамические характеристики и эффективность реализации алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-matcher.png|1280px]]

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-reduce.png|1280px]]

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-overall.png|1280px]]

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

=== Динамические характеристики и эффективность реализации алгоритма ===

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

=== Выводы для классов архитектур ===

Данный метод должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов.

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:05:19Z

Bagnikita: /* Существующие реализации алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-matcher.png|1280px]]

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-reduce.png|1280px]]

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-overall.png|1280px]]

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

=== Динамические характеристики и эффективность реализации алгоритма ===

TODO

=== Выводы для классов архитектур ===

Данный метод должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов.

=== Существующие реализации алгоритма ===

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T21:03:14Z

Bagnikita: /* Выводы для классов архитектур */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-matcher.png|1280px]]

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-reduce.png|1280px]]

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-overall.png|1280px]]

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

=== Динамические характеристики и эффективность реализации алгоритма ===

TODO

=== Выводы для классов архитектур ===

Данный метод должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов.

=== Существующие реализации алгоритма ===

TODO

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T15:58:02Z

Bagnikita: /* Исследование влияния HyperThreading на работу алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-matcher.png|1280px]]

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-reduce.png|1280px]]

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-overall.png|1280px]]

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

=== Динамические характеристики и эффективность реализации алгоритма ===

TODO

=== Выводы для классов архитектур ===

TODO

=== Существующие реализации алгоритма ===

TODO

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T15:57:06Z

Bagnikita: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат без HyperThreading, красная - HyperThreading включен.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-matcher.png|1280px]]

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-reduce.png|1280px]]

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-overall.png|1280px]]

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

=== Динамические характеристики и эффективность реализации алгоритма ===

TODO

=== Выводы для классов архитектур ===

TODO

=== Существующие реализации алгоритма ===

TODO

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T15:52:35Z

Bagnikita: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат без HyperThreading, красная - HyperThreading включен.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-matcher.png|1280px]]

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-reduce.png|1280px]]

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-overall.png|1280px]]

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T15:51:38Z

Bagnikita: /* Исследование влияния HyperThreading на работу алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат без HyperThreading, красная - HyperThreading включен.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-matcher.png|1280px]]

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-reduce.png|1280px]]

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-overall.png|1280px]]

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T15:50:01Z

Bagnikita: /* Программная реализация алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

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

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

=== Масштабируемость алгоритма и его реализации ===

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат без HyperThreading, красная - HyperThreading включен.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-matcher.png|1280px]]

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-reduce.png|1280px]]

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp (10-56 потоков):
[[Файл:Facerecognition-ht-overall.png|1280px]]

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T15:42:29Z

Bagnikita: /* Возможные способы и особенности параллельной реализации алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

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

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T15:40:32Z

Bagnikita: /* Возможные способы и особенности параллельной реализации алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

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

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T15:38:48Z

Bagnikita: /* Возможные способы и особенности параллельной реализации алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Суммарная скорость работы системы в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_overall.png|1280px]]

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T15:35:38Z

Bagnikita: /* Практическая реализация системы */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Программная реализация алгоритма ==

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

=== Особенности реализации последовательного алгоритма ===

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

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

=== Локальность данных и вычислений ===

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

=== Возможные способы и особенности параллельной реализации алгоритма ===

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Результаты работы map функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition-matcher.png|1280px]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|1280px]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Суммарная скорость работы системы:
[[Файл:Facerecognition_overall.png|1280px]]

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T14:21:14Z

Bagnikita: /* Быстрое сравнение биометрических шаблонов */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Практическая реализация системы ==

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

=== Быстрое сравнение биометрических шаблонов ===

При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций. Набор инструкций FMA позволяет выполнять операцию <math>y = ax + b</math> без дополнительных операций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Применение openmp позволило ускорить версию с обычным циклом до 1300ms, что медленнее FMA3. Вычисление в несколько потоков не ускорило реализацию на FMA3. Вероятно, причина в пропускной способности оперативной памяти - для DDR4 15GBps на канал. Объем тестовой базы 15.5GB, поэтому не менее 500ms должно было занять чтение из памяти.

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

На сервере (2x E5-2683v3 256GB RAM, база 150М биометрических шаблонов) получилось следующее ускорение от использования FMA3 + OpenMP (MOPS - количество операций сравнения в секунду):

[[Файл:Facerecognition-matcher.png|1280px]]

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

Количество операций с плавающей точкой (умножения) для сравнения биометрических шаблонов: <math>n*128</math> FLOP.

=== Быстрое формирование результата ===

Если на каждой операции поиска изображения в базе необходимо выбирать максимальную фотографию для каждого челокека в базе, то задача сводится к классической map/reduce:
* map - вычисление скалярных произведений
* reduce - группировка результатов по людям и выдача N максимально похожих

В reduce применение openmp позволило увеличить скорость с 3000ms до 1000ms на 4 ядрах процессора (ноутбук с 6300HQ, 30M записей в базе)

Из дальшейнего фрагмента кода очевидно, что при таком распараллеливании нет зависимостей по переменным. Эксперимент показал, что применять openmp для inplace_merge неэффективно для текущих ограничений на размер базы (200-300M).

<source lang="c++">
vector<MatchResult> OMP_Blob::reduce(size_t top_k, bool merge_person)
{
const int num_chunks = static_cast<int>(_chunks.size());

vector<MatchResult> result;
vector<vector<MatchResult>> results(num_chunks);
#pragma omp parallel for num_threads(_num_threads)
for(int i = 0; i < num_chunks; ++i) {
results[i] = _chunks[i].reduce(top_k, merge_person, false);
}

for(int i = 0; i < num_chunks; ++i) {
result.insert(result.end(), results[i].begin(), results[i].end());
}

if(merge_person) {
size_t csum = 0;
for(int i = 0; i < num_chunks; ++i) {
inplace_merge(result.begin(), result.begin() + csum, result.begin() + csum + results[i].size(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id < b.person_id || (a.person_id == b.person_id && a.score > b.score);
});
csum += results[i].size();
}
result.resize(unique(result.begin(), result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id == b.person_id;
}) - result.begin());
}
size_t result_size = min(top_k, result.size());
partial_sort(result.begin(), result.begin() + result_size, result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.score > b.score;
});
result.resize(result_size);
result.shrink_to_fit();
return result;
}
</source>

Финальную сортировку результатов по score ускорять не требуется, поскольку top_k на практике не более 1000. Параллельная реализация в данном случае будет неэффективна.

[[Файл:Facerecognition_reduce.png|1280px]]

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T14:19:03Z

Bagnikita: /* Быстрое формирование результата */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Практическая реализация системы ==

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

=== Быстрое сравнение биометрических шаблонов ===

При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций. Набор инструкций FMA позволяет выполнять операцию <math>y = ax + b</math> без дополнительных операций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Применение openmp позволило ускорить версию с обычным циклом до 1300ms, что медленнее FMA3. Вычисление в несколько потоков не ускорило реализацию на FMA3. Вероятно, причина в пропускной способности оперативной памяти - для DDR4 15GBps на канал. Объем тестовой базы 15.5GB, поэтому не менее 500ms должно было занять чтение из памяти.

На сервере (2x E5-2683v3 256GB RAM, база 150М биометрических шаблонов) получилось следующее ускорение от использования FMA3 + OpenMP (MOPS - количество операций сравнения в секунду):

[[Файл:Facerecognition-matcher.png|1280px]]

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

Количество операций с плавающей точкой (умножения) для сравнения биометрических шаблонов: <math>n*128</math> FLOP.

=== Быстрое формирование результата ===

Если на каждой операции поиска изображения в базе необходимо выбирать максимальную фотографию для каждого челокека в базе, то задача сводится к классической map/reduce:
* map - вычисление скалярных произведений
* reduce - группировка результатов по людям и выдача N максимально похожих

В reduce применение openmp позволило увеличить скорость с 3000ms до 1000ms на 4 ядрах процессора (ноутбук с 6300HQ, 30M записей в базе)

Из дальшейнего фрагмента кода очевидно, что при таком распараллеливании нет зависимостей по переменным. Эксперимент показал, что применять openmp для inplace_merge неэффективно для текущих ограничений на размер базы (200-300M).

<source lang="c++">
vector<MatchResult> OMP_Blob::reduce(size_t top_k, bool merge_person)
{
const int num_chunks = static_cast<int>(_chunks.size());

vector<MatchResult> result;
vector<vector<MatchResult>> results(num_chunks);
#pragma omp parallel for num_threads(_num_threads)
for(int i = 0; i < num_chunks; ++i) {
results[i] = _chunks[i].reduce(top_k, merge_person, false);
}

for(int i = 0; i < num_chunks; ++i) {
result.insert(result.end(), results[i].begin(), results[i].end());
}

if(merge_person) {
size_t csum = 0;
for(int i = 0; i < num_chunks; ++i) {
inplace_merge(result.begin(), result.begin() + csum, result.begin() + csum + results[i].size(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id < b.person_id || (a.person_id == b.person_id && a.score > b.score);
});
csum += results[i].size();
}
result.resize(unique(result.begin(), result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id == b.person_id;
}) - result.begin());
}
size_t result_size = min(top_k, result.size());
partial_sort(result.begin(), result.begin() + result_size, result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.score > b.score;
});
result.resize(result_size);
result.shrink_to_fit();
return result;
}
</source>

Финальную сортировку результатов по score ускорять не требуется, поскольку top_k на практике не более 1000. Параллельная реализация в данном случае будет неэффективна.

[[Файл:Facerecognition_reduce.png|1280px]]

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T14:17:38Z

Bagnikita: /* Быстрое сравнение биометрических шаблонов */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Практическая реализация системы ==

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

=== Быстрое сравнение биометрических шаблонов ===

При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций. Набор инструкций FMA позволяет выполнять операцию <math>y = ax + b</math> без дополнительных операций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Применение openmp позволило ускорить версию с обычным циклом до 1300ms, что медленнее FMA3. Вычисление в несколько потоков не ускорило реализацию на FMA3. Вероятно, причина в пропускной способности оперативной памяти - для DDR4 15GBps на канал. Объем тестовой базы 15.5GB, поэтому не менее 500ms должно было занять чтение из памяти.

На сервере (2x E5-2683v3 256GB RAM, база 150М биометрических шаблонов) получилось следующее ускорение от использования FMA3 + OpenMP (MOPS - количество операций сравнения в секунду):

[[Файл:Facerecognition-matcher.png|1280px]]

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

Количество операций с плавающей точкой (умножения) для сравнения биометрических шаблонов: <math>n*128</math> FLOP.

=== Быстрое формирование результата ===

Если на каждой операции поиска изображения в базе необходимо выбирать максимальную фотографию для каждого челокека в базе, то задача сводится к классической map/reduce:
* map - вычисление скалярных произведений
* reduce - группировка результатов по людям и выдача N максимально похожих

В reduce применение openmp позволило увеличить скорость с 3000ms до 1000ms на 4 ядрах процессора (ноутбук с 6300HQ, 30M записей в базе)

Из дальшейнего фрагмента кода очевидно, что при таком распараллеливании нет зависимостей по переменным. Эксперимент показал, что применять openmp для inplace_merge неэффективно для текущих ограничений на размер базы (200-300M).

<source lang="c++">
vector<MatchResult> OMP_Blob::reduce(size_t top_k, bool merge_person)
{
const int num_chunks = static_cast<int>(_chunks.size());

vector<MatchResult> result;
vector<vector<MatchResult>> results(num_chunks);
#pragma omp parallel for num_threads(_num_threads)
for(int i = 0; i < num_chunks; ++i) {
results[i] = _chunks[i].reduce(top_k, merge_person, false);
}

for(int i = 0; i < num_chunks; ++i) {
result.insert(result.end(), results[i].begin(), results[i].end());
}

if(merge_person) {
size_t csum = 0;
for(int i = 0; i < num_chunks; ++i) {
inplace_merge(result.begin(), result.begin() + csum, result.begin() + csum + results[i].size(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id < b.person_id || (a.person_id == b.person_id && a.score > b.score);
});
csum += results[i].size();
}
result.resize(unique(result.begin(), result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id == b.person_id;
}) - result.begin());
}
size_t result_size = min(top_k, result.size());
partial_sort(result.begin(), result.begin() + result_size, result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.score > b.score;
});
result.resize(result_size);
result.shrink_to_fit();
return result;
}
</source>

Финальную сортировку результатов по score ускорять не требуется, поскольку top_k на практике не более 1000.

[[Файл:Facerecognition_reduce.png|1280px]]

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T14:17:06Z

Bagnikita: /* Быстрое сравнение биометрических шаблонов */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Практическая реализация системы ==

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

=== Быстрое сравнение биометрических шаблонов ===

При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций. Набор инструкций FMA позволяет выполнять операцию <math>y = ax + b</math> без дополнительных операций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Применение openmp позволило ускорить версию с обычным циклом до 1300ms, что медленнее FMA3. Вычисление в несколько потоков не ускорило реализацию на FMA3. Вероятно, причина в пропускной способности оперативной памяти - для DDR4 15GBps на канал. Объем тестовой базы 15.5GB, поэтому не менее 500ms должно было занять чтение из памяти.

На сервере (2x E5-2683v3 256GB RAM, база 150М биометрических шаблонов) получилось следующее ускорение от использования FMA3 + OpenMP (MOPS - количество операций сравнения в секунду):

[[Файл:Facerecognition-matcher.png|1280px|thumb]]

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

Количество операций с плавающей точкой (умножения) для сравнения биометрических шаблонов: <math>n*128</math> FLOP.

=== Быстрое формирование результата ===

Если на каждой операции поиска изображения в базе необходимо выбирать максимальную фотографию для каждого челокека в базе, то задача сводится к классической map/reduce:
* map - вычисление скалярных произведений
* reduce - группировка результатов по людям и выдача N максимально похожих

В reduce применение openmp позволило увеличить скорость с 3000ms до 1000ms на 4 ядрах процессора (ноутбук с 6300HQ, 30M записей в базе)

Из дальшейнего фрагмента кода очевидно, что при таком распараллеливании нет зависимостей по переменным. Эксперимент показал, что применять openmp для inplace_merge неэффективно для текущих ограничений на размер базы (200-300M).

<source lang="c++">
vector<MatchResult> OMP_Blob::reduce(size_t top_k, bool merge_person)
{
const int num_chunks = static_cast<int>(_chunks.size());

vector<MatchResult> result;
vector<vector<MatchResult>> results(num_chunks);
#pragma omp parallel for num_threads(_num_threads)
for(int i = 0; i < num_chunks; ++i) {
results[i] = _chunks[i].reduce(top_k, merge_person, false);
}

for(int i = 0; i < num_chunks; ++i) {
result.insert(result.end(), results[i].begin(), results[i].end());
}

if(merge_person) {
size_t csum = 0;
for(int i = 0; i < num_chunks; ++i) {
inplace_merge(result.begin(), result.begin() + csum, result.begin() + csum + results[i].size(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id < b.person_id || (a.person_id == b.person_id && a.score > b.score);
});
csum += results[i].size();
}
result.resize(unique(result.begin(), result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id == b.person_id;
}) - result.begin());
}
size_t result_size = min(top_k, result.size());
partial_sort(result.begin(), result.begin() + result_size, result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.score > b.score;
});
result.resize(result_size);
result.shrink_to_fit();
return result;
}
</source>

Финальную сортировку результатов по score ускорять не требуется, поскольку top_k на практике не более 1000.

[[Файл:Facerecognition_reduce.png|1280px]]

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T14:15:31Z

Bagnikita: /* Быстрое формирование результата */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Практическая реализация системы ==

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

=== Быстрое сравнение биометрических шаблонов ===

При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций. Набор инструкций FMA позволяет выполнять операцию <math>y = ax + b</math> без дополнительных операций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Применение openmp позволило ускорить версию с обычным циклом до 1300ms, что медленнее FMA3. Вычисление в несколько потоков не ускорило реализацию на FMA3. Вероятно, причина в пропускной способности оперативной памяти - для DDR4 15GBps на канал. Объем тестовой базы 15.5GB, поэтому не менее 500ms должно было занять чтение из памяти.

На сервере (2x E5-2683v3 256GB RAM, база 150М биометрических шаблонов) получилось следующее ускорение от использования FMA3 + OpenMP (MOPS - количество операций сравнения в секунду):

[[Файл:Facerecognition-matcher.png|1280px]]

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

Количество операций с плавающей точкой (умножения) для сравнения биометрических шаблонов: <math>n*128</math> FLOP.

=== Быстрое формирование результата ===

Если на каждой операции поиска изображения в базе необходимо выбирать максимальную фотографию для каждого челокека в базе, то задача сводится к классической map/reduce:
* map - вычисление скалярных произведений
* reduce - группировка результатов по людям и выдача N максимально похожих

В reduce применение openmp позволило увеличить скорость с 3000ms до 1000ms на 4 ядрах процессора (ноутбук с 6300HQ, 30M записей в базе)

Из дальшейнего фрагмента кода очевидно, что при таком распараллеливании нет зависимостей по переменным. Эксперимент показал, что применять openmp для inplace_merge неэффективно для текущих ограничений на размер базы (200-300M).

<source lang="c++">
vector<MatchResult> OMP_Blob::reduce(size_t top_k, bool merge_person)
{
const int num_chunks = static_cast<int>(_chunks.size());

vector<MatchResult> result;
vector<vector<MatchResult>> results(num_chunks);
#pragma omp parallel for num_threads(_num_threads)
for(int i = 0; i < num_chunks; ++i) {
results[i] = _chunks[i].reduce(top_k, merge_person, false);
}

for(int i = 0; i < num_chunks; ++i) {
result.insert(result.end(), results[i].begin(), results[i].end());
}

if(merge_person) {
size_t csum = 0;
for(int i = 0; i < num_chunks; ++i) {
inplace_merge(result.begin(), result.begin() + csum, result.begin() + csum + results[i].size(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id < b.person_id || (a.person_id == b.person_id && a.score > b.score);
});
csum += results[i].size();
}
result.resize(unique(result.begin(), result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id == b.person_id;
}) - result.begin());
}
size_t result_size = min(top_k, result.size());
partial_sort(result.begin(), result.begin() + result_size, result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.score > b.score;
});
result.resize(result_size);
result.shrink_to_fit();
return result;
}
</source>

Финальную сортировку результатов по score ускорять не требуется, поскольку top_k на практике не более 1000.

[[Файл:Facerecognition_reduce.png|1280px]]

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T14:14:56Z

Bagnikita: /* Быстрое формирование результата */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Практическая реализация системы ==

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

=== Быстрое сравнение биометрических шаблонов ===

При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций. Набор инструкций FMA позволяет выполнять операцию <math>y = ax + b</math> без дополнительных операций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Применение openmp позволило ускорить версию с обычным циклом до 1300ms, что медленнее FMA3. Вычисление в несколько потоков не ускорило реализацию на FMA3. Вероятно, причина в пропускной способности оперативной памяти - для DDR4 15GBps на канал. Объем тестовой базы 15.5GB, поэтому не менее 500ms должно было занять чтение из памяти.

На сервере (2x E5-2683v3 256GB RAM, база 150М биометрических шаблонов) получилось следующее ускорение от использования FMA3 + OpenMP (MOPS - количество операций сравнения в секунду):

[[Файл:Facerecognition-matcher.png|1280px]]

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

Количество операций с плавающей точкой (умножения) для сравнения биометрических шаблонов: <math>n*128</math> FLOP.

=== Быстрое формирование результата ===

Если на каждой операции поиска изображения в базе необходимо выбирать максимальную фотографию для каждого челокека в базе, то задача сводится к классической map/reduce:
* map - вычисление скалярных произведений
* reduce - группировка результатов по людям и выдача N максимально похожих

В reduce применение openmp позволило увеличить скорость с 3000ms до 1000ms на 4 ядрах процессора (ноутбук с 6300HQ, 30M записей в базе)

Из дальшейнего фрагмента кода очевидно, что при таком распараллеливании нет зависимостей по переменным. Эксперимент показал, что применять openmp для inplace_merge неэффективно для текущих ограничений на размер базы (200-300M).

<source lang="c++">
vector<MatchResult> OMP_Blob::reduce(size_t top_k, bool merge_person)
{
const int num_chunks = static_cast<int>(_chunks.size());

vector<MatchResult> result;
vector<vector<MatchResult>> results(num_chunks);
#pragma omp parallel for num_threads(_num_threads)
for(int i = 0; i < num_chunks; ++i) {
results[i] = _chunks[i].reduce(top_k, merge_person, false);
}

for(int i = 0; i < num_chunks; ++i) {
result.insert(result.end(), results[i].begin(), results[i].end());
}

if(merge_person) {
size_t csum = 0;
for(int i = 0; i < num_chunks; ++i) {
inplace_merge(result.begin(), result.begin() + csum, result.begin() + csum + results[i].size(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id < b.person_id || (a.person_id == b.person_id && a.score > b.score);
});
csum += results[i].size();
}
result.resize(unique(result.begin(), result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id == b.person_id;
}) - result.begin());
}
size_t result_size = min(top_k, result.size());
partial_sort(result.begin(), result.begin() + result_size, result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.score > b.score;
});
result.resize(result_size);
result.shrink_to_fit();
return result;
}
</source>

Финальную сортировку результатов по score ускорять не требуется, поскольку top_k на практике не более 1000.

[[Файл:faceredognition_reduce.png]]

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T14:13:19Z

Bagnikita: /* Свойства алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

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

== Практическая реализация системы ==

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

=== Быстрое сравнение биометрических шаблонов ===

При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций. Набор инструкций FMA позволяет выполнять операцию <math>y = ax + b</math> без дополнительных операций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Применение openmp позволило ускорить версию с обычным циклом до 1300ms, что медленнее FMA3. Вычисление в несколько потоков не ускорило реализацию на FMA3. Вероятно, причина в пропускной способности оперативной памяти - для DDR4 15GBps на канал. Объем тестовой базы 15.5GB, поэтому не менее 500ms должно было занять чтение из памяти.

На сервере (2x E5-2683v3 256GB RAM, база 150М биометрических шаблонов) получилось следующее ускорение от использования FMA3 + OpenMP (MOPS - количество операций сравнения в секунду):

[[Файл:Facerecognition-matcher.png|1280px]]

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

Количество операций с плавающей точкой (умножения) для сравнения биометрических шаблонов: <math>n*128</math> FLOP.

=== Быстрое формирование результата ===

Если на каждой операции поиска изображения в базе необходимо выбирать максимальную фотографию для каждого челокека в базе, то задача сводится к классической map/reduce:
* map - вычисление скалярных произведений
* reduce - группировка результатов по людям и выдача N максимально похожих

В reduce применение openmp позволило увеличить скорость с 3000ms до 1000ms на 4 ядрах процессора (ноутбук с 6300HQ, 30M записей в базе)

Из дальшейнего фрагмента кода очевидно, что при таком распараллеливании нет зависимостей по переменным. Эксперимент показал, что применять openmp для inplace_merge неэффективно для текущих ограничений на размер базы (200-300M).

<source lang="c++">
vector<MatchResult> OMP_Blob::reduce(size_t top_k, bool merge_person)
{
const int num_chunks = static_cast<int>(_chunks.size());

vector<MatchResult> result;
vector<vector<MatchResult>> results(num_chunks);
#pragma omp parallel for num_threads(_num_threads)
for(int i = 0; i < num_chunks; ++i) {
results[i] = _chunks[i].reduce(top_k, merge_person, false);
}

for(int i = 0; i < num_chunks; ++i) {
result.insert(result.end(), results[i].begin(), results[i].end());
}

if(merge_person) {
size_t csum = 0;
for(int i = 0; i < num_chunks; ++i) {
inplace_merge(result.begin(), result.begin() + csum, result.begin() + csum + results[i].size(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id < b.person_id || (a.person_id == b.person_id && a.score > b.score);
});
csum += results[i].size();
}
result.resize(unique(result.begin(), result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id == b.person_id;
}) - result.begin());
}
size_t result_size = min(top_k, result.size());
partial_sort(result.begin(), result.begin() + result_size, result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.score > b.score;
});
result.resize(result_size);
result.shrink_to_fit();
return result;
}
</source>

Финальную сортировку результатов по score ускорять не требуется, поскольку top_k на практике не более 1000.

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T14:06:14Z

Bagnikita: /* Свойства алгоритма */

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились [https://research.facebook.com/publications/deepface-closing-the-gap-to-human-level-performance-in-face-verification/ системы], точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

=== Математическое описание алгоритма ===

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки ([https://developer.nvidia.com/cudnn NVIDIA cuDNN]) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как [https://www.microsoft.com/en-us/research/publication/bayesian-face-revisited-a-joint-formulation/ Joint Bayesian]. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

=== Вычислительное ядро алгоритма ===

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором.

=== Макроструктура алгоритма ===

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

=== Схема реализации последовательного алгоритма ===

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

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

=== Последовательная сложность алгоритма ===

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

=== Информационный граф ===

TODO

=== Ресурс параллелизма алгоритма ===

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

=== Входные и выходные данные алгоритма ===

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

=== Свойства алгоритма ===

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

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

== Практическая реализация системы ==

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

=== Быстрое сравнение биометрических шаблонов ===

При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций. Набор инструкций FMA позволяет выполнять операцию <math>y = ax + b</math> без дополнительных операций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Применение openmp позволило ускорить версию с обычным циклом до 1300ms, что медленнее FMA3. Вычисление в несколько потоков не ускорило реализацию на FMA3. Вероятно, причина в пропускной способности оперативной памяти - для DDR4 15GBps на канал. Объем тестовой базы 15.5GB, поэтому не менее 500ms должно было занять чтение из памяти.

На сервере (2x E5-2683v3 256GB RAM, база 150М биометрических шаблонов) получилось следующее ускорение от использования FMA3 + OpenMP (MOPS - количество операций сравнения в секунду):

[[Файл:Facerecognition-matcher.png|1280px]]

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

Количество операций с плавающей точкой (умножения) для сравнения биометрических шаблонов: <math>n*128</math> FLOP.

=== Быстрое формирование результата ===

Если на каждой операции поиска изображения в базе необходимо выбирать максимальную фотографию для каждого челокека в базе, то задача сводится к классической map/reduce:
* map - вычисление скалярных произведений
* reduce - группировка результатов по людям и выдача N максимально похожих

В reduce применение openmp позволило увеличить скорость с 3000ms до 1000ms на 4 ядрах процессора (ноутбук с 6300HQ, 30M записей в базе)

Из дальшейнего фрагмента кода очевидно, что при таком распараллеливании нет зависимостей по переменным. Эксперимент показал, что применять openmp для inplace_merge неэффективно для текущих ограничений на размер базы (200-300M).

<source lang="c++">
vector<MatchResult> OMP_Blob::reduce(size_t top_k, bool merge_person)
{
const int num_chunks = static_cast<int>(_chunks.size());

vector<MatchResult> result;
vector<vector<MatchResult>> results(num_chunks);
#pragma omp parallel for num_threads(_num_threads)
for(int i = 0; i < num_chunks; ++i) {
results[i] = _chunks[i].reduce(top_k, merge_person, false);
}

for(int i = 0; i < num_chunks; ++i) {
result.insert(result.end(), results[i].begin(), results[i].end());
}

if(merge_person) {
size_t csum = 0;
for(int i = 0; i < num_chunks; ++i) {
inplace_merge(result.begin(), result.begin() + csum, result.begin() + csum + results[i].size(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id < b.person_id || (a.person_id == b.person_id && a.score > b.score);
});
csum += results[i].size();
}
result.resize(unique(result.begin(), result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.person_id == b.person_id;
}) - result.begin());
}
size_t result_size = min(top_k, result.size());
partial_sort(result.begin(), result.begin() + result_size, result.end(), [](const MatchResult &a, const MatchResult &b) {
return a.score > b.score;
});
result.resize(result_size);
result.shrink_to_fit();
return result;
}
</source>

Финальную сортировку результатов по score ускорять не требуется, поскольку top_k на практике не более 1000.

[[Категория:Нейронные сети]]

Участник:Bagnikita/Face Recognition

2016-10-14T13:56:03Z

Bagnikita: /* Входные и выходные данные алгоритма */

Участник:Bagnikita/Face Recognition

2016-10-14T13:51:12Z

Bagnikita: /* Ресурс параллелизма алгоритма */

Участник:Bagnikita/Face Recognition

2016-10-14T13:38:18Z

Bagnikita: /* Ресурс параллелизма алгоритма */

Участник:Bagnikita/Face Recognition

2016-10-14T13:35:27Z

Bagnikita: /* Ресурс параллелизма алгоритма */

Участник:Bagnikita/Face Recognition

2016-10-14T13:20:43Z

Bagnikita: /* Общее описание алгоритма */

Участник:Bagnikita/Face Recognition

2016-10-14T13:20:21Z

Bagnikita: /* Последовательная сложность алгоритма */

Участник:Bagnikita/Face Recognition

2016-10-14T13:10:46Z

Bagnikita: /* Макроструктура алгоритма */

Участник:Bagnikita/Face Recognition

2016-10-14T13:09:18Z

Bagnikita: /* Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе */

Участник:Bagnikita/Face Recognition

2016-10-14T13:09:00Z

Bagnikita: /* Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе */