Распознавание лиц
Обзор
Face SDK позволяет выполнять следующие операции сравнения биометрических шаблонов лиц:
- Верификация (1:1) — сравнение двух шаблонов лиц на принадлежность одному и тому же человеку (сравнение двух лиц).
- Идентификация (1:N) — сравнение одного биометрического шаблона лица с другими шаблонами лиц (поиск лица по базе лиц).
Результатом распознавания является оценка сходства между сравниваемыми шаблонами.
Процессинг-блоки распознавания лиц
Для распознавания лиц используются следующие процессинг-блоки:
FACE_TEMPLATE_EXTRACTOR
— используются для построения биометрических шаблонов лиц.VERIFICATION_MODULE
— используется для сравнения двух лиц.MATCHER_MODULE
— используются для поиска лиц по базе.TEMPLATE_INDEX
— нужен для создания базы биометрических шаблонов лиц для поиска в модуле MATCHER_MODULE.
Модификации и версии процессинг-блоков распознавания лиц
Модификация процессинг-блока FACE_TEMPLATE_EXTRACTOR
определяет скорость генерации шаблона и точность распознавания. Чем медленнее работа модуля, тем выше его точность распознавания.
На данный момент существуют следующие модификации:
- 1000
- 100
- 50
- 30
Версия | Создание шаблона (мс) | Размер шаблона (байты) |
---|---|---|
1 | 647 | 296 |
Версия | Создание шаблона (мс) | Размер шаблона (байты) |
---|---|---|
1 | 79 | 280 |
Версия | Создание шаблона (мс) | Размер шаблона (байты) |
---|---|---|
1 | 37 | 288 |
Версия | Создание шаблона (мс) | Размер шаблона (байты) |
---|---|---|
1 | 23 | 280 |
Модификация по умолчанию - "1000"
.
Для процессинг-блоков VERIFICATION_MODULE
, MATCHER_MODULE
, TEMPLATE_INDEX
модификация и версия определяют тип шаблона, с которым данные модули будут работать.
Спецификация процессинг-блоков распознавания
Перечень настраиваемых параметров процессинг-блоков
Face template extractor
- Входной контейнер 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]]
}
}]
}
- После вызова процессинг-блока оценки, каждому объекту из массива
"objects"
в поле"template"
будет добавлен биометрический шаблон в поле соответствующее данной модификации. Биометрический шаблон лица будет представлен в бинарном виде.
Нажмите, чтобы развернуть спецификацию выходного контейнера Context
[{
"keypoints": {},
"template": {
"face_template_extractor_{modification}_{version}": {
"format": "NDARRAY",
"blob": "data pointer",
"dtype": "uint8_t",
"shape": [size]
}
}
}]
Verification module
- Входной контейнер 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]
}
}
}
- После вызова процессинг-блока верификации результат будет помещён в
"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
- Входной контейнер Context должен содержать массив биометрических шаблонов записанных в поле `"templates".
Нажмите, чтобы развернуть спецификацию входного контейнера Context
{
"templates" : [
"face_template_extractor_{modification}_{version}": {
"format": "NDARRAY",
"blob": "data pointer",
"dtype": "uint8_t",
"shape": [size]
},
]
}
- После вызова процессинг-блока создания индекса, полученный индекс будет помещён в поле
"template_index"
.
Нажмите, чтобы развернуть спецификацию выходного контейнера Context
[{
"templates": {},
"template_index": {"Non-serializable"}
}]
Matcher module
- Входной контейнер 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"}
}
- После вызова процессинг-блока верификации результат будет помещён в массив
"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%). Высокая степень схожести означает, что два биометрических шаблона принадлежат одному и тому же человеку.
Примеры работы с процессинг-блоками распознавания лиц
Извлечение шаблонов лица
Для получения шаблона лица на изображении выполните следующие действия:
Создайте конфигурационный Context-контейнер и укажите значения
"unit_type"
для"FACE_TEMPLATE_EXTRACTOR"
и"modification"
и"version"
интересующей вас модификации.Пример создания процессинг-блока можно найти здесь
Передайте Context-контейнер, полученный после работы процессинг-блоков детекции лица и фиттера.
Вызовите процессинг-блок извлечения шаблонов лица.
- C++
- Python
- Flutter
- C#
- Java
- Kotlin
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);configCtx = {"unit_type": "FACE_TEMPLATE_EXTRACTOR", "modification": "{modification}" }
blockFaceExtractor = service.create_processing_block(configCtx)
#------------------
# создание процессинг-блока и Context-контейнера с бинарным изображением
#------------------
faceDetector(ioData)
faceFitter(ioData)
blockFaceExtractor(ioData)ProcessingBlock blockFaceExtractor = service.createProcessingBlock({"unit_type": "FACE_TEMPLATE_EXTRACTOR", "modification": "{modification}"});
//------------------
// создание процессинг-блока и Context-контейнера с бинарным изображением
//------------------
faceDetector.process(ioData);
faceFitter.process(ioData);
blockFaceExtractor.process(ioData);Dictionary<object, object> configCtx = new();
configCtx["unit_type"] = "FACE_TEMPLATE_EXTRACTOR";
configCtx["modification"] = "{modification}";
ProcessingBlock blockFaceExtractor = service.CreateProcessingBlock(configCtx);
//------------------
// создание процессинг-блока и Context-контейнера с бинарным изображением
//------------------
faceDetector.Invoke(ioData);
faceFitter.Invoke(ioData);
blockFaceExtractor.Invoke(ioData);Context configCtx = service.createContext();
configCtx.get("unit_type").setString("FACE_TEMPLATE_EXTRACTOR");
configCtx.get("modification").setString("{modification}");
ProcessingBlock blockFaceExtractor = service.createProcessingBlock(configCtx);
//------------------
// создание процессинг-блока и Context-контейнера с бинарным изображением
//------------------
faceDetector.process(ioData);
faceFitter.process(ioData);
blockFaceExtractor.process(ioData);val configCtx = service.createContext()
configCtx["unit_type"].string = "FACE_TEMPLATE_EXTRACTOR"
configCtx["modification"].string = "{modification}"
val blockFaceExtractor = service.createProcessingBlock(configCtx)
//------------------
// создание процессинг-блока и Context-контейнера с бинарным изображением
//------------------
faceDetector.process(ioData)
faceFitter.process(ioData)
blockFaceExtractor.process(ioData)
Сохранение шаблона лица
Для сохранения шаблона лица в файле выполните следующие действия:
Получите бинарные данные шаблона лица и размер шаблона.
Создайте файл для записи бинарных данных.
Запишите бинарные данные шаблона лица в файл.
- C++
- Python
- Flutter
- C#
- Java
- Kotlin
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);template_ctx = ioData["objects"][0]["template"]
template_size = template_ctx["face_template_extractor_{modification}_{version}"]["shape"][0].get_value()
template_bytes = template_ctx["face_template_extractor_{modification}_{version}"]["blob"].get_bytes(template_size)
with open("template.bin", "wb") as file:
file.write(template_bytes)Context templateCtx = ioData["objects"][0]["template"];
int templateSize = templateCtx["face_template_extractor_{modification}_{version}"]["shape"][0].get_value();
Uint8List templateBytes = templateCtx["face_template_extractor_{modification}_{version}"]["blob"].getBytes(templateSize);
final out = File("template.bin");
await out.writeAsBytes(templateBytes);Context templateCtx = ioData["objects"][0]["template"];
int templateSize = (int) templateCtx["face_template_extractor_{modification}_{version}"]["shape"][0].GetLong();
byte[] templateBytes = templateCtx["face_template_extractor_{modification}_{version}"]["blob"].GetBytes(templateSize);
File.WriteAllBytes("template.bin", templateBytes);Context template_ctx = ioData.get("objects").get(0).get("template");
int template_size = (int)template_ctx.get("face_template_extractor_{modification}_{version}").get("shape").get(0).getLong();
byte[] template_bytes = template_ctx.get("face_template_extractor_{modification}_{version}").get("blob").getBytes(template_size);
try (FileOutputStream stream = new FileOutputStream("template.bin"))
{
stream.write(template_bytes);
}
catch (IOException ioe)
{
ioe.printStackTrace();
}val template_ctx = ioData["objects"][0]["template"]
val template_size = template_ctx["face_template_extractor_{modification}_{version}"]["shape"][0].long
val template_bytes = template_ctx["face_template_extractor_{modification}_{version}"]["blob"].getBytes(template_size);
try {
FileOutputStream("template.bin").use { stream ->
stream.write(template_bytes)
}
} catch (ioe: IOException) {
ioe.printStackTrace()
}
Загрузка шаблона лица
Для загрузки шаблона лица из файла выполните следующие действия:
Откройте файл для чтения бинарных данных.
Создайте массив байтов и считайте данные из файла.
Сформируте контейнер-Context для шаблона лица.
- C++
- Python
- Flutter
- C#
- Java
- Kotlin
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";with open("template.bin", "rb") as file:
template_bytes = file.read(template_size)
template_ctx = service.create_context({
"face_template_extractor_{modification}_{version}": {
"blob": template_bytes,
"shape": [template_size],
"dtype": "uint8_t",
"format": "NDARRAY",
}
})final input = File("template.bin");
Uint8List templateBytes = await input.readAsBytes();
Context templateCtx = service.createContext({
"face_template_extractor_{modification}_{version}": {
"blob": templateBytes,
"shape": [templateSize],
"dtype": "uint8_t",
"format": "NDARRAY",
}
});byte [] templateBytes = File.ReadAllBytes("template.bin");
Context templateCtx = service.CreateContext(new Dictionary<object, object>()
{
{
"face_template_extractor_{modification}_{version}", new Dictionary<object, object>()
{
{"blob", templateBytes},
{"shape", new List<object>(){templateSize}},
{"dtype", "uint8_t"},
{"format", "NDARRAY"},
}
}
});byte[] template_bytes = new byte[template_size];
try (FileInputStream stream = new FileInputStream("template.bin"))
{
stream.read(template_bytes);
}
catch (IOException ioe)
{
ioe.printStackTrace();
}
Context template_ctx = service.createContext();
template_ctx.get("face_template_extractor_{modification}_{version}").get("blob").setBytes(template_bytes);
template_ctx.get("face_template_extractor_{modification}_{version}").get("shape").pushBack(template_size);
template_ctx.get("face_template_extractor_{modification}_{version}").get("dtype").setString("uint8_t");
template_ctx.get("face_template_extractor_{modification}_{version}").get("format").pushBack("NDARRAY");val template_bytes = ByteArray(template_size)
try {
FileInputStream("template.bin").use { stream ->
stream.read(template_bytes)
}
} catch (ioe: IOException) {
ioe.printStackTrace()
}
val template_ctx = service.createContext()
template_ctx["face_template_extractor_{modification}_{version}"]["blob"].setBytes(template_bytes)
template_ctx["face_template_extractor_{modification}_{version}"]["shape"].pushBack(template_size)
template_ctx["face_template_extractor_{modification}_{version}"]["dtype"].string = "uint8_t"
template_ctx["face_template_extractor_{modification}_{version}"]["format"].pushBack("NDARRAY")
Верификация лиц
Создайте конфигурационный Context-контейнер и укажите значения
"unit_type"
для"VERIFICATION_MODULE"
и"modification"
и"version"
интересующей вас модификации.Сформируйте Context-контейнер согласно спецификации. В ключи
"template1"
и"template2"
передайте содержимое поля"template"
, полученного при вызове"FACE_TEMPLATE_EXTRACTOR"
.Вызовите процессинг-блок верификации.
- C++
- Python
- Flutter
- C#
- Java
- Kotlin
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);configCtx = {"unit_type": "VERIFICATION_MODULE", "modification": "{modification}"}
verificationModule = service.create_processing_block(configCtx)
verificationData = service.create_context({})
verificationData["template1"] = ioData1["objects"][0]["template"]
verificationData["template2"] = ioData2["objects"][0]["template"]
verificationModule(verificationData)
ProcessingBlock verificationModule = service.createProcessingBlock({"unit_type": "VERIFICATION_MODULE", "modification": "{modification}"});
Context verificationData = service.createContext({"template1": {}, "template2": {}});
verificationData["template1"].placeValues(ioData1["objects"][0]["template"])
verificationData["template2"].placeValues(ioData2["objects"][0]["template"])
verificationModule.process(verificationData);Dictionary<object, object> verificationConfig = new();
verificationConfig["unit_type"] = "VERIFICATION_MODULE";
verificationConfig["modification"] = "{modification}";
ProcessingBlock verificationModule = service.CreateProcessingBlock(verificationConfig);
Context verificationData = service.CreateContext(null);
verificationData["template1"] = ioData["objects"][0]["template"];
verificationData["template2"] = ioData2["objects"][0]["template"];
verificationModule.Invoke(verificationData);Context verificationConfig = service.createContext();
verificationConfig.get("unit_type").setString("VERIFICATION_MODULE");
verificationConfig.get("modification").setString("{modification}");
ProcessingBlock verificationModule = service.createProcessingBlock(verificationConfig);
Context verificationData = service.createContext();
verificationData.get("template1").setContext(ioData.get("objects").get(0).get("template"));
verificationData.get("template2").setContext(ioData2.get("objects").get(0).get("template"));
verificationModule.process(verificationData);val verificationConfig = service.createContext()
verificationConfig["unit_type"].string = "VERIFICATION_MODULE"
verificationConfig["modification"].string = "{modification}"
val verificationModule = service.createProcessingBlock(verificationConfig)
val verificationData = service.createContext()
verificationData["template1"].setContext(ioData["objects"][0]["template"])
verificationData["template2"].setContext(ioData2["objects"][0]["template"])
verificationModule.process(verificationData)
Поиск лиц по базе
Создайте конфигурационный Context-контейнер и укажите значения
"unit_type"
для"TEMPLATE_INDEX"
и"modification"
и"version"
интересующей вас модификации.Сформируйте входной Context-контейнер согласно спецификации для
"TEMPLATE_INDEX"
.Вызовете процессинг-блок для создания базы шаблонов.
Создайте конфигурационный Context-контейнер и укажите значения
"unit_type"
для"MATCHER_MODULE"
и"modification"
и"version"
интересующей вас модификации.Сформируйте входной Context-контейнер согласно спецификации для
"MATCHER_MODULE"
.Вызовите процессинг-блок для поиска по базе.
- C++
- Python
- Flutter
- C#
- Java
- Kotlin
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);template_index = service.create_processing_block({"unit_type": "TEMPLATE_INDEX", "modification": "{modification}"})
templatesData = service.create_context([])
for object in ioData["objects"]:
templatesData["templates"].push_back(object["template"])
template_index(templatesData)
matcher_module = service.create_processing_block({"unit_type": "MATCHER_MODULE", "modification": "{modification}"})
matcher_data = service.create_context({})
matcher_data["template_index"] = templatesData["template_index"]
matcher_data["queries"].push_back(ioData2["objects"][0])
matcher_module(matcher_data)ProcessingBlock templateIndex = service.createProcessingBlock({"unit_type": "TEMPLATE_INDEX", "modification": "{modification}"});
// формирование входного Context-контейнера для templateIndex
Context templatesData = service.createContext({"templates": []});
for (int i = 0; i < ioData["objects"].len(); i++){
templatesData["templates"].pushBack(ioData["objects"][i]["template"]);
}
templateIndex.process(templatesData);
matcherModule = service.createProcessingBlock({"unit_type": "MATCHER_MODULE", "modification": "{modification}"});
// формирование входного Context-контейнера для matcherModule
Context matcherData = service.createContext({"template_index": {}, "queries": []});
matcherData["template_index"] = templatesData["template_index"];
matcherData["queries"].pushBack(ioData2["objects"][0]);
matcherModule.process(matcherData);Dictionary<object, object> templateIndexConfig = new();
templateIndexConfig["unit_type"] = "TEMPLATE_INDEX";
templateIndexConfig["modification"] = "{modification}";
ProcessingBlock templateIndex = service.CreateProcessingBlock(templateIndexConfig);
// формирование входного Context-контейнера для templateIndex
Context templatesData = service.CreateContext(new Dictionary<object, object>{{ "templates", new() }});
for (int i = 0; i < (int)ioData["objects"].Length(); i++)
{
templatesData["templates"].PushBack(ioData["objects"][i]["template"]);
}
templateIndex.Invoke(templatesData);
Dictionary<object, object> matcherConfig = new();
matcherConfig["unit_type"] = "MATCHER_MODULE";
matcherConfig["modification"] = "{modification}";
ProcessingBlock matcherModule = service.CreateProcessingBlock(matcherConfig);
// формирование входного Context-контейнера для matcherModule
Context matcherData = service.CreateContext(new Dictionary<object, object>{
{ "template_index", new() },
{ "queries", new() },
});
matcherData["template_index"] = templatesData["template_index"];
matcherData["queries"].PushBack(ioData2["objects"][0]);
matcherModule.Invoke(matcherData);
Context templateIndexConfig = service.createContext();
templateIndexConfig.get("unit_type").setString("TEMPLATE_INDEX");
templateIndexConfig.get("modification").setString("{modification}");
ProcessingBlock templateIndex = service.createProcessingBlock(templateIndexConfig);
// формирование входного Context-контейнера для templateIndex
Context templatesData = service.createContext();
Context objects = ioData.get("objects");
for (int i = 0; i < objects.size(); i++)
{
templatesData.get("templates").pushBack(objects.get(i).get("template"));
}
templateIndex.process(templatesData);
Context matcherConfig = service.createContext();
matcherConfig.get("unit_type").setString("MATCHER_MODULE");
matcherConfig.get("modification").setString("{modification}");
ProcessingBlock matcherModule = service.createProcessingBlock(matcherConfig);
// формирование входного Context-контейнера для matcherModule
Context matcherData = service.createContext();
matcherData.get("template_index").setContext(templatesData.get("template_index"));
matcherData.get("queries").pushBack(ioData2.get("objects").get(0));
matcherModule.process(matcherData);val templateIndexConfig = service.createContext()
templateIndexConfig["unit_type"]).string = "TEMPLATE_INDEX"
templateIndexConfig["modification"]).string = "{modification}"
val templateIndex = service.createProcessingBlock(templateIndexConfig)
// формирование входного Context-контейнера для templateIndex
val templatesData = service.createContext()
val objects = ioData["objects"]
for (i in 0 until objects.size()) {
templatesData["templates"].pushBack(objects[i]["template"])
}
templateIndex.process(templatesData)
val matcherConfig = service.createContext()
matcherConfig["unit_type"].string = "MATCHER_MODULE"
matcherConfig["modification"].string ="{modification}"
val matcherModule = service.createProcessingBlock(matcherConfig)
// формирование входного Context-контейнера для matcherModule
val matcherData = service.createContext()
matcherData["template_index"].setContext(templatesData.["template_index"])
matcherData["queries"].pushBack(ioData2["objects"][0])
matcherModule.process(matcherData)