Перейти к основному содержимому
Версия: 3.24.1 (последняя)

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

Обзор

Face SDK позволяет выполнять следующие операции сравнения биометрических шаблонов лиц:

  • Верификация (1:1) — сравнение двух шаблонов лиц на принадлежность одному и тому же человеку (сравнение двух лиц).
  • Идентификация (1:N) — сравнение одного биометрического шаблона лица с другими шаблонами лиц (поиск лица по базе лиц).

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

Процессинг-блоки распознавания лиц

Для распознавания лиц используются следующие процессинг-блоки:

  • FACE_TEMPLATE_EXTRACTOR — используются для построения биометрических шаблонов лиц.
  • VERIFICATION_MODULE — используется для сравнения двух лиц.
  • MATCHER_MODULE — используются для поиска лиц по базе.
  • TEMPLATE_INDEX — нужен для создания базы биометрических шаблонов лиц для поиска в модуле MATCHER_MODULE.

Модификации и версии процессинг-блоков распознавания лиц

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

ВерсияСоздание шаблона (мс)Размер шаблона (байты)
1 647 296
примечание

Модификация по умолчанию - "1000".

Для процессинг-блоков VERIFICATION_MODULE, MATCHER_MODULE, TEMPLATE_INDEX модификация и версия определяют тип шаблона, с которым данные модули будут работать.

Спецификация процессинг-блоков распознавания

Перечень настраиваемых параметров процессинг-блоков

Face template extractor

  1. Входной контейнер Context должен содержать бинарное изображение и массив объектов, полученных после работы процессинг-блоков детекции лица и фиттера:
Нажмите, чтобы развернуть спецификацию входного контейнера Context
{
"image" : {
"format": "NDARRAY",
"blob": "data pointer",
"dtype": "uint8_t",
"shape": [height, width, channels]
},
"objects": [{
"id": {"type": "long", "minimum": 0},
"class": "face",
"confidence": {"double", "minimum": 0, "maximum": 1},
"bbox": [x1, y2, x2, y2]
"keypoints": {
"left_eye_brow_left": {"proj" : [x, y]},
"left_eye_brow_up": {"proj" : [x, y]},
"left_eye_brow_right": {"proj" : [x, y]},
"right_eye_brow_left": {"proj" : [x, y]},
"right_eye_brow_up": {"proj" : [x, y]},
"right_eye_brow_right": {"proj" : [x, y]},
"left_eye_left": {"proj" : [x, y]},
"left_eye": {"proj" : [x, y]},
"left_eye_right": {"proj" : [x, y]},
"right_eye_left": {"proj" : [x, y]},
"right_eye": {"proj" : [x, y]},
"right_eye_right": {"proj" : [x, y]},
"left_ear_bottom": {"proj" : [x, y]},
"nose_left": {"proj" : [x, y]},
"nose": {"proj" : [x, y]},
"nose_right": {"proj" : [x, y]},
"right_ear_bottom": {"proj" : [x, y]},
"mouth_left": {"proj" : [x, y]},
"mouth": {"proj" : [x, y]},
"mouth_right": {"proj" : [x, y]},
"chin": {"proj" : [x, y]},
"points": ["proj": [x, y]]
}
}]
}
  1. После вызова процессинг-блока оценки, каждому объекту из массива "objects" в поле "template"будет добавлен биометрический шаблон в поле соответствующее данной модификации. Биометрический шаблон лица будет представлен в бинарном виде.
Нажмите, чтобы развернуть спецификацию выходного контейнера Context
[{
"keypoints": {},
"template": {
"face_template_extractor_{modification}_{version}": {
"format": "NDARRAY",
"blob": "data pointer",
"dtype": "uint8_t",
"shape": [size]
}
}
}]

Verification module

  1. Входной контейнер Context должен содержать два биометрических шаблона записанные в поля "template1" и "templatу2". Тип шаблона должен соответствовать модификации процессинг-блока.
Нажмите, чтобы развернуть спецификацию входного контейнера Context
{
"template1" : {
"face_template_extractor_{modification}_{version}": {
"format": "NDARRAY",
"blob": "data pointer",
"dtype": "uint8_t",
"shape": [size]
}
},
"template2" : {
"face_template_extractor_{modification}_{version}": {
"format": "NDARRAY",
"blob": "data pointer",
"dtype": "uint8_t",
"shape": [size]
}
}
}
  1. После вызова процессинг-блока верификации результат будет помещён в "result".
Нажмите, чтобы развернуть спецификацию выходного контейнера Context
[{
"template2": {},
"result": {
"distance": {"long", "minimum": 0},
"score": {"double", "minimum": 0, "maximum": 1},
"far": {"double", "minimum": 0, "maximum": 1},
"frr": {"double", "minimum": 0, "maximum": 1},
}
}]

Template index module

  1. Входной контейнер Context должен содержать массив биометрических шаблонов записанных в поле `"templates".
Нажмите, чтобы развернуть спецификацию входного контейнера Context
{
"templates" : [
"face_template_extractor_{modification}_{version}": {
"format": "NDARRAY",
"blob": "data pointer",
"dtype": "uint8_t",
"shape": [size]
},
]
}
  1. После вызова процессинг-блока создания индекса, полученный индекс будет помещён в поле "template_index".
Нажмите, чтобы развернуть спецификацию выходного контейнера Context
[{
"templates": {},
"template_index": {"Non-serializable"}
}]

Matcher module

  1. Входной контейнер Context должен содержать массив "template_index", полученный после работы модуля "TEMPLATE_INDEX". И набор искомых биометрических шаблонов помещённых в массив "queries"
Нажмите, чтобы развернуть спецификацию входного контейнера Context
{
"queries": [
"template" : {
"face_template_extractor_{modification}_{version}": {
"format": "NDARRAY",
"blob": "data pointer",
"dtype": "uint8_t",
"shape": [size]
},
}
]
"template_index": {"Non-serializable"}
}
  1. После вызова процессинг-блока верификации результат будет помещён в массив "results".
Нажмите, чтобы развернуть спецификацию выходного контейнера Context
[{
"template_index": {"Non-serializable"},
"result": [{
"distance": {"long", "minimum": 0},
"score": {"double", "minimum": 0, "maximum": 1},
"far": {"double", "minimum": 0, "maximum": 1},
"frr": {"double", "minimum": 0, "maximum": 1},
}]
}]

Результаты распознавания

  • distance – расстояние между сравниваемыми векторами шаблонов. Чем меньше значение, тем выше уверенность в корректном распознавании.
  • far – вероятность ошибочных подтверждений, когда система принимает изображения разных людей за изображение одного и того же человека.
  • frr – вероятность ошибочных отказов, когда система принимает два изображения одного и того же человека за изображения разных людей.
  • score – степень схожести лиц от 0 (0%) до 1 (100%). Высокая степень схожести означает, что два биометрических шаблона принадлежат одному и тому же человеку.

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

Извлечение шаблонов лица

Для получения шаблона лица на изображении выполните следующие действия:

  1. Создайте конфигурационный Context-контейнер и укажите значения "unit_type" для "FACE_TEMPLATE_EXTRACTOR" и "modification" и "version" интересующей вас модификации.

    Пример создания процессинг-блока можно найти здесь

    Перечень настраиваемых параметров процессинг-блоков

  2. Передайте Context-контейнер, полученный после работы процессинг-блоков детекции лица и фиттера.

  3. Вызовите процессинг-блок извлечения шаблонов лица.

    auto configCtx = service->createContext();
    configCtx["unit_type"] = "FACE_TEMPLATE_EXTRACTOR";
    configCtx["modification"] = "{modification}";
    pbio::ProcessingBlock blockFaceExtractor = service->createProcessingBlock(configCtx);

    //------------------
    // создание процессинг-блока и Context-контейнера с бинарным изображением
    //------------------

    faceDetector(ioData)
    faceFitter(ioData)
    blockFaceExtractor(ioData);

Сохранение шаблона лица

Для сохранения шаблона лица в файле выполните следующие действия:

  1. Получите бинарные данные шаблона лица и размер шаблона.

  2. Создайте файл для записи бинарных данных.

  3. Запишите бинарные данные шаблона лица в файл.

    auto template_ctx = ioData["objects"][0]["template"];
    size_t template_size = template_ctx["face_template_extractor_{modification}_{version}"]["shape"][0].getLong();
    uint8_t* template_ptr = template_ctx["face_template_extractor_{modification}_{version}"]["blob"].getDataPtr();

    std::ofstream out("template.bin", std::ios::binary);

    out.write(reinterpret_cast<char*>(template_ptr), template_size);

Загрузка шаблона лица

Для загрузки шаблона лица из файла выполните следующие действия:

  1. Откройте файл для чтения бинарных данных.

  2. Создайте массив байтов и считайте данные из файла.

  3. Сформируте контейнер-Context для шаблона лица.

    std::ifstream input("template.bin", std::ios::binary);

    uint8_t* template_ptr = new uint8_t[template_size];
    input.read(reinterpret_cast<char*>(template_ptr), template_size);

    auto template_ctx = service.createContext();
    template_ctx["face_template_extractor_{modification}_{version}"]["blob"].setDataPtr(template_ptr, template_size);
    template_ctx["face_template_extractor_{modification}_{version}"]["shape"].push_back(template_size);
    template_ctx["face_template_extractor_{modification}_{version}"]["dtype"] = "uint8_t";
    template_ctx["face_template_extractor_{modification}_{version}"]["format"] = "NDARRAY";

Верификация лиц

  1. Создайте конфигурационный Context-контейнер и укажите значения "unit_type" для "VERIFICATION_MODULE" и "modification" и "version" интересующей вас модификации.

  2. Сформируйте Context-контейнер согласно спецификации. В ключи "template1" и "template2" передайте содержимое поля "template", полученного при вызове "FACE_TEMPLATE_EXTRACTOR".

  3. Вызовите процессинг-блок верификации.

    Context verificationConfig = service.createContext();
    verificationConfig["unit_type"] = "VERIFICATION_MODULE";
    verificationConfig["modification"] = "{modification}";

    api::ProcessingBlock verificationModule = service.createProcessingBlock(verificationConfig);

    Context verificationData = service.createContext();
    verificationData["template1"] = ioData["objects"][0]["template"];
    verificationData["template2"] = ioData2["objects"][0]["template"];

    verificationModule(verificationData);

Поиск лиц по базе

  1. Создайте конфигурационный Context-контейнер и укажите значения "unit_type" для "TEMPLATE_INDEX" и "modification" и "version" интересующей вас модификации.

  2. Сформируйте входной Context-контейнер согласно спецификации для "TEMPLATE_INDEX".

  3. Вызовете процессинг-блок для создания базы шаблонов.

  4. Создайте конфигурационный Context-контейнер и укажите значения "unit_type" для "MATCHER_MODULE" и "modification" и "version" интересующей вас модификации.

  5. Сформируйте входной Context-контейнер согласно спецификации для "MATCHER_MODULE".

  6. Вызовите процессинг-блок для поиска по базе.


    Context templateIndexConfig = service.createContext();
    templateIndexConfig["unit_type"] = "TEMPLATE_INDEX";
    templateIndexConfig["modification"] = "{modification}";

    api::ProcessingBlock templateIndex = service.createProcessingBlock(templateIndexConfig);

    // формирование входного Context-контейнера для templateIndex
    Context templatesData = service.createContext();
    for (const Context& object : ioData["objects"])
    {
    templatesData["templates"].push_back(object["template"]);
    }

    templateIndex(templatesData);

    Context matcherConfig = service.createContext();
    matcherConfig["unit_type"] = "MATCHER_MODULE";
    matcherConfig["modification"] = "{modification}";

    api::ProcessingBlock matcherModule = service.createProcessingBlock(matcherConfig);

    // формирование входного Context-контейнера для matcherModule
    Context matcherData = service.createContext();
    matcherData["template_index"] = templatesData["template_index"];
    matcherData["queries"].push_back(ioData2["objects"][0]);

    matcherModule(matcherData);