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

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

Обзор​

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);