Разработка кросплатформенного приложения на Qt с использованием нейросетей, обученных на tensorflow

Раз уж Вы заинтересовались данной статьёй, то ожидается, что Вы умеете программировать на с++ с использованием библиотеки Qt и разрабатывать нейросети на Python c использованием библиотеки tensorflow.
Соответственно остаётся только понять как использовать обученные Вами нейросетевые модели в Qt проектах.

Чтобы использовать нейросети в проектах с Qt нужно сделать следующее:

• Скачать и откомпилировать для нужной платформы tensorflow

• Скачать и откомпилировать для нужной платформы opencv

• Скачать android SDK и настроить Qt для работы с ним

• В pro файле Qt указать местоположение директории с заголовочными файлами и сами откомпилированные библиотеки

• Написать программу

• Для Android задействовать аппаратное ускорение

Скачать и откомпилировать для нужной платформы tensorflow

Скачать исходные коды можно с официального сайта.
Для этого в папке, в которой Вы планируете хранить проекты, выполните (в консоли, конечно) git clone https://github.com/tensorflow/tensorflow.git и командой
git checkout branch_name выберите нужную версию tensorflow.

Для компиляции tensorflow Вам понадобится bazel. Но каждая версия tensorflow требует своей версии basel. Чтобы не париться самому с версиями, стоит установить bazelisk. Для чего скачиваем бинарник с https://github.com/bazelbuild/bazelisk/releases, и кладём в системную папку с программами, например в /usr/local/bin (для linux), после чего при компиляции вместо настоящего bazel будет запускаться bazelisk, при необходимости скачивать нужную версию bazel и компилировать с его помощью.

Есть два варианта использования tensorflow:

• используя оригинальный tensorflow

• используя tensorflow lite

Оригинальный tensorflow

Плюсы:

• Использование оригинального файла сохранения модели

• Возможность обучать модель

Минусы:

• Сложный интерфейс. Тут именно tensorflow без keras, то есть Вы оперируете не понятиями модель, слой, а понятиями вычислительный граф, вычислительная операция

• Огромный размер библиотеки около 300 MB

• Нет настроек для компиляции под мобильные ОС

Tensorflow lite

Плюсы:

• Простой интерфейс, хоть и не такой как keras

• Маленький размер библиотеки - несколько мегабайт

• Есть настройки компиляции под мобильные ОС

Минусы:

• Необходимость преобразовывать формат ".h5" в формат ".tflite" (делается одной командой на python).

• Могут поддерживаться не все операции (в моей модели таких не было).

Компиляция библиотеки под оригинальный tensorflow

Для компиляции необходимо выполнить следующие команды:
Устанавливаем protobuf:

git clone https://github.com/protocolbuffers/protobuf.git 
cd protobufgit 
checkout 3.9.x
./autogen.sh
./confugure
make -j$(nproc)
sudo make install
sudo ldconfig

git clone https://github.com/tensorflow/tensorflowcd tensorflow
git checkout r2.7
git clone https://github.com/abseil/abseil-cpp.git
ln -s abseil-cpp/absl ./absl/

Добавить googleprotobuf*; в tensorflow/tensorflow/tf_version_script.lds
После чего:

./confugure
bazelisk build --jobs=10 --verbose_failures -c opt --config=monolithic //tensorflow:libtensorflow_cc.so

Следует отметить, что версия protobuf должна соответствовать версии tensorflow. Я нашёл соответствие по выдаваемой при компиляции tensorflow ошибке.

Компиляция библиотеки под tensorflow lite

Для компиляции необходимо выполнить следующие команды:

git clone https://github.com/tensorflow/tensorflow
cd tensorflow
git checkout r2.7
./configure
bazelisk build -c opt --config=android_arm64 --config=monolithic //tensorflow/lite:libtensorflowlite.so

./confugure в интерактивном режиме настроит сборку, если настройка для компиляции под android, Вам потребуется указать местоположение Android NDK, которую вы скачали в составе Android studio.
Здесь android_arm64 - настройки для компиляции под 64 битную версию android.
Замените на android_arm для компиляции под 32 битную версию android.
Уберите --config=android_arm64 для компиляции под ту ОС, в которой Вы ведёте разработку.
Ссылка по теме на официальный сайт https://www.tensorflow.org/lite/android/development

После компиляции появится директория bazel-bin, в которой скомпилированная библиотека будет находится в директории tensorflow/lite

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

Набор инструкций	Флаги
AVX	--copt=-mavx
AVX2	--copt=-mavx2
FMA	--copt=-mfma
SSE 4.1	--copt=-msse4.1
SSE 4.2	--copt=-msse4.2
Все поддерживаемые процессором	--copt=-march=native

но в таком случае на некоторых компьютерах ПО может не работать.

В pro файле проекта на Qt для android следует добавить следующие строки:

INCLUDEPATH += "Путь к папке с tensorflow"
INCLUDEPATH += "Путь к папке с tensorflow"/bazel-bin/
INCLUDEPATH += "Путь к папке с tensorflow"/bazel-tensorflow/external
INCLUDEPATH += "Путь к папке с tensorflow"/bazel-bin/external/flatbuffers/_virtual_includes/flatbuffers

LIBS += -L"Путь к папке с tensorflow"/bazel-bin/tensorflow/lite -ltensorflowlite

Скачать и откомпилировать для нужной платформы opencv

Выполнить git clone https://github.com/opencv/opencv.git
Перейти на нужную версию git checkout "Ветка", для каждой версии opencv есть ветка.
Рядом с директорией opencv создать директорию, например opencv_build, в которой для каждой платформы создать свою директорию.
В директории opencv_build для платформы Android 64 создавать скрипты следующего содержания, заменяя
"Папка куда будет вестись компиляция под конкретную ОС"
"Папка с конкретной версией android NDK"
"Папка с результатом сборки",
Вашими названиями папок.

# !/bin/bash  
cd "Папка куда будет вестись компиляция под конкретную ОС"  
rm -R *  
PATH=$PATH:"Папка с конкретной версией android NDK"/toolchains/llvm/prebuilt/linux-x86_64/bin  
export ANDROID_HOME="Папка с  SDK"  
export ANDROID_SDK_ROOT="Папка с  SDK"  
export CMAKE_CONFIG_GENERATOR="Unix Makefiles"  
cmake -DCMAKE_BUILD_TYPE=Debug -DANDROID_NATIVE_API_LEVEL=lastest -DANDROID_ABI=arm64-v8a -DCMAKE_BUILD_TYPE=Debug -G"$CMAKE_CONFIG_GENERATOR" -DANDROID_ARM_NEON=ON -DANDROID_STL=c++_static -DBUILD_ANDROID_PROJECTS:BOOL=ON -DBUILD_opencv_world:BOOL=OFF -DBUILD_PERF_TESTS:BOOL=OFF -DBUILD_TESTS:BOOL=OFF -DBUILD_DOCS:BOOL=OFF -DWITH_CUDA:BOOL=ON -DBUILD_EXAMPLES:BOOL=OFF -DENABLE_PRECOMPILED_HEADERS=OFF -DWITH_IPP=ON -DWITH_MSMF=ON -DOPENCV_ENABLE_NONFREE:BOOL=ON -DWITH_OPENEXR=OFF -DWITH_CAROTENE=ON \-DINSTALL_CREATE_DISTRIB=ON -DOPENCV_EXTRA_MODULES_PATH=../../opencv_contrib/modules -DCMAKE_TOOLCHAIN_FILE="Папка с конкретной версией android NDK"/build/cmake/android.toolchain.cmake ../../opencv  
make -j16  
cmake --install . --prefix "Папка с результатом сборки"

Для 32-битной Android платформы нужно arm64-v8a заменить на armeabi-v7a

Для desktop платформы скрипт будет следующий:

#!/bin/bash
cd "Папка куда будет вестись компиляция под конкретную ОС"
rm -R *
cmake ../../opencv
make -j16
cmake --install . --prefix "Папка с результатом сборки"

В pro файле проекта следует добавить для desktop следующее:

INCLUDEPATH += "Папка с результатом сборки"/include/opencv4    
LIBS += -L"Папка с результатом сборки"/lib \    
-lopencv_dnn \    
-lopencv_videoio \    
-lopencv_objdetect \    
-lopencv_calib3d \    
-lopencv_imgcodecs \    
-lopencv_features2d \    
-lopencv_flann \    
-lopencv_imgproc \    
-lopencv_core

В pro файле проекта следует добавить для android следующее:

OPENCV_ANDROID = "Папка с результатом сборки"
INCLUDEPATH += "$$OPENCV_ANDROID/sdk/native/jni/include"
LIBS += -lmediandkcontains(ANDROID_TARGET_ARCH,armeabi-v7a){   
LIBS += \           
-L"$$OPENCV_ANDROID/sdk/native/3rdparty/libs/$$ANDROID_TARGET_ARCH" \                
-ltbb \                
-lIlmImf        }        
LIBS += \            
-L"$$OPENCV_ANDROID/sdk/native/libs/$$ANDROID_TARGET_ARCH" \            
-L"$$OPENCV_ANDROID/sdk/native/staticlibs/$$ANDROID_TARGET_ARCH" \            
-L"$$OPENCV_ANDROID/sdk/native/3rdparty/libs/$$ANDROID_TARGET_ARCH" \            
-lade \            
-littnotify \            
-llibjpeg-turbo \            
-llibwebp \            
-llibpng \            
-llibtiff \            
-llibopenjp2 \            
-lquirc \            
-ltegra_hal \            
-lopencv_dnn \            
-lopencv_objdetect \            
-lopencv_calib3d \            
-lopencv_imgcodecs \            
-lopencv_features2d \            
-lopencv_flann \            
-lopencv_imgproc \            
-lopencv_core \            
-lopencv_videoio \            
-lcpufeatures \            
-llibprotobuf \        
ANDROID_EXTRA_LIBS = $$OPENCV_ANDROID/sdk/native/libs/arm64-v8a/libopencv_java4.so

Так же для компиляции под desktop tensorflow необходим flatbuffers

Установим его в систему глобально следующими командами:

git clone https://github.com/google/flatbuffers.git
cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release
make
sudo make install
sudo ldconfig

Вы можете установить flatbuffers локально заменив
sudo make install
cmake --install . --prefix "Папка с результатом сборки",
а затем с помощью INCLUDEPATH += и LIBS += добавить к проекту Qt

Разработка ПО

Здесь я опишу работу с tensorflow lite

Для работы с tensorflow lite преобразуем модель в его формат:

model.save('model_full')
converter = tf.lite.TFLiteConverter.from_saved_model('model_full') # path to the SavedModel directory
tflite_model = converter.convert()

# Save the model.
with open('model.tflite', 'wb') as f:
  f.write(tflite_model)

Если вы планируете задействовать аппаратное ускорение на Андроид устройствах(делегаты) то вам необходимо при конвертации указать постоянный размер batch, иначе, если в вашей нейросети присутствуют например слой Reshape модель работать не будет. Естественно в самой программе на с++ нужно задать тот же размер batch(по умолчанию 1).
Для этого используйте следующий код вместо вышеприведённого:

# model - ваша модель
batch_size = 1 
input_shape = model.inputs[0].shape.as_list()
input_shape[0] = batch_size
func = tf.function(model).get_concrete_function(tf.TensorSpec(input_shape, model.inputs[0].dtype))
converter = tf.lite.TFLiteConverter.from_concrete_functions([func])

tflite_model = converter.convert()

with open('my_model.tflite', 'wb') as f:
  f.write(tflite_model)

Теперь подключим необходимые библиотеки:

#include <opencv2/opencv.hpp>
#include "tensorflow/lite/interpreter.h"
#include "tensorflow/lite/kernels/register.h"
#include "tensorflow/lite/c/c_api_types.h"

Теперь загрузим модель:

std::unique_ptr<tflite::FlatBufferModel> m_model;
tflite::ops::builtin::BuiltinOpResolver resolver;
std::unique_ptr<tflite::Interpreter> interpreter;
m_model = tflite::FlatBufferModel::BuildFromFile("путь к модели");
tflite::InterpreterBuilder builder(*m_model, resolver);
TfLiteStatus tatus = builder(&interpreter);
interpreter->AllocateTensors();

Если status == kTfLiteOk, то можем выполнять инференс модели.

Получим размерности входного и выходного слоёв:

// получаем размерность входа
const std::vector<int>& t_inputs = m_interpreter->inputs();
TfLiteTensor* tensor = m_interpreter->tensor(t_inputs[0]);
int batch = tensor->dims->data[0];
w = tensor->dims->data[1];
h = tensor->dims->data[2];
c = tensor->dims->data[3];


// получаем размерность выхода
const std::vector<int>& t_outputs = m_interpreter->outputs();
TfLiteTensor* out_tensor = m_interpreter->tensor(t_outputs[0]);
m_output_len = out_tensor->dims->data[1];

Задать размер batch можно используя
m_interpreter->ResizeInputTensor(t_inputs[0], {batch_len,w,h,c});
Сколько потоков использовать для инференса можно задать с помощью
m_interpreter->SetNumThreads(16);

Делаем инференс модели.
В данном примере вход берётся видеофрейм cv:Mat , выходом же будет массив из 9 чисел (вероятностей конкретного класса).

// загружаем данные на входной слой
сonst size_t DATA_SIZE 224*224*3
float* input = interpreter->typed_input_tensor<float>(0);
auto *from_data = (uint8_t*)frame.data;.
copy(from_data, from_data + DATA_SIZE, input);

// делаем инференс
auto status = interpreter->Invoke();

// разбираем данные с выходного слоя
float* output = interpreter->typed_output_tensor<float>(0);
if (status == kTfLiteOk)
  {
    auto size = 9;
    int max_idx {0};
    float max = output[0];
    static const vector<string> emo_names = {"злость", "презрение", "отвращение", "страх", "радость", "норма", "печаль",
                                      "удивление", "неуверенность"};
    vector<string> emotions;
    for (int i = 0; i < size; ++i)
      {
        float curr_val = output[i];
        if (curr_val > 0.2)
          emotions.push_back(emo_names[i]);
        if (curr_val > max)
          {
            max_idx = i;
            max = curr_val;
          }
      }

    return emotions;
  }
else
  return {"predict error"};

Очень часто распознавать требуется кадры из видео-потока веб камеры или камеры смартфона, что программно одно и тоже. Захват можно делать либо средствами opencv, либо средствами Qt. Делать захват средствами opencv заманчиво, так как с полученным кадром можно удобно делать множество операций, например, вырезать заданную область, но у меня так и не получилось заставить работать захват через opencv под android. Поэтому я сделал захват и вывод видео-потока средствами Qt, а преобразования кадров средствами opencv. Так работает под все платформы.

Для захвата камеры нужно создать 3 объекта:

QScopedPointer<QCamera> m_camera;
QVideoSink *m_video_sink{new QVideoSink{this}};
QMediaCaptureSession m_captureSession;

После чего выбрать камеру (например, камеру по умолчанию) и связать данные объекты:

m_camera.reset(QMediaDevices::defaultVideoInput());
m_captureSession.setCamera(m_camera.data());
m_camera->start();
m_captureSession.setVideoSink(m_video_sink);

После чего периодически опрашивать видео-поток и преобразовывать изображение в cv:Mat:

m_curr_image = m_video_sink->videoFrame().toImage();
m_frame = QImage2Mat(m_curr_image);

Вот функции преобразования из QImage в cv::Mat и обратно:

using namespace cv;

QImage Mat2QImage(cv::Mat const& src)
{
     cv::Mat temp; // make the same cv::Mat
     cvtColor(src, temp, COLOR_BGR2RGBA); // cvtColor Makes a copt, that what i need
     QImage dest((const uchar *) temp.data, temp.cols, temp.rows, temp.step, QImage::Format_RGB32);
     dest.bits(); // enforce deep copy, see documentation
     // of QImage::QImage ( const uchar * data, int width, int height, Format format )
     return dest;
}

cv::Mat QImage2Mat(QImage const& src)
{
     cv::Mat tmp(src.height(),src.width(),CV_8UC4,(uchar*)src.bits(),src.bytesPerLine());
     cv::Mat result; // deep copy just in case (my lack of knowledge with open cv)
     cvtColor(tmp, result, COLOR_RGBA2BGR);
     return result;
}

Кроме своих моделей полезно использовать чужие, уже обученные, например, в opencv встроена модель детекции лиц cv::dnn::Net, вот пример:

auto prepared_frame = cv::dnn::blobFromImage(frame, 1.0, Size(300,300), Scalar(104.0, 177.0, 123.0));
m_face_detect_model.setInput(prepared_frame);
Mat output = m_face_detect_model.forward();
const int SHIFT = 7;
using currTp = Vec<float,SHIFT>;
auto it = output.begin<currTp>();
while(it != output.end<currTp>())
  {
    currTp pred = *it;
    if (pred[2] < 0.5)
      break;

    int x = pred[3]*m_img_width;
    int y = pred[4]*m_img_height;
    int width = (pred[5] - pred[3])*m_img_width;
    int height = (pred[6] - pred[4])*m_img_height;
    coords.push_back(Rect{x, y, width, height});
    it+=SHIFT;
  }

Правда под Android модели opencv у меня работали крайне неэффективно, раз в 40 хуже, чем обученные мной tensorflow модели. Если кто-то знает как это исправить пишите, буду рад.
Tensorflow предоставляет кучу готовых, обученных моделей компьютерного зрения в проекте mediapipe и под python их можно удобно использовать, но под с++ планируется, что Вы интегрируетесь в mediapipe, а не наоборот, так как планируется, что если Вы используете с++, то Вам необходим минимальный объём приложения.
Идея mediapipe заключается в том, что пишется текстовый файл в специальном формате, в котором описывается путь данных от ввода, например, с камеры, до вывода на экран устройства этот файл подаётся на вход программе, реализующей общий код приложения. Если какое-то преобразование не существует в mediapipe, то пишется класс наследуемый от mediapipe::CalculatorBase, в котором реализуется данное преобразование. Подробнее можно прочитать по ссылке. Но это уже тема отдельной статьи.

Вот ссылка на готовый проект
В нём есть ветки с разными реализациями.

Использование аппаратного ускорения на android устройствах

Для использования аппаратного ускорения нужно применять делегаты.
Ссылка по ним на сайте tensorflow https://www.tensorflow.org/lite/performance/delegates?hl=ru
В данном примере добавим nnapi и gpu делегаты, делается это следующим образом :

Подключаем библиотеки(только под android)

#if defined(Q_OS_ANDROID)
#include "tensorflow/lite/delegates/nnapi/nnapi_delegate.h"
#include "tensorflow/lite/delegates/gpu/delegate.h"
#endif  // ANDROID

При создании модели создаём делегатов и указываем их модели

std::unique_ptr<tflite::FlatBufferModel> m_model;
tflite::ops::builtin::BuiltinOpResolver resolver;
std::unique_ptr<tflite::Interpreter> interpreter;
m_model = tflite::FlatBufferModel::BuildFromFile("Имя файла с моделью tflite");
tflite::InterpreterBuilder builder(*m_model, resolver);
#ifdef Q_OS_ANDROID
  auto* delegate = TfLiteGpuDelegateV2Create(/*default options=*/nullptr);
  builder.AddDelegate(delegate);
  builder.AddDelegate(tflite::NnApiDelegate());
#endif

m_status = builder(&interpreter);
interpreter->AllocateTensors();

После этого пользуемся моделью как обычно.

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

В директории с tensorflow заходим в tensorflow/lite/
там находим файл BUILD
в нём по ключевому слову tensorflowlite ищем раздел tflite_cc_shared_object в котором
name = "tensorflowlite" вот пример:

tflite_cc_shared_object(
    name = "tensorflowlite",
    # Until we have more granular symbol export for the C++ API on Windows,
    # export all symbols.
    features = ["windows_export_all_symbols"],
    linkopts = select({
        "//tensorflow:macos": [
            "-Wl,-exported_symbols_list,$(location //tensorflow/lite:tflite_exported_symbols.lds)",
        ],
        "//tensorflow:windows": [],
        "//conditions:default": [
            "-Wl,-z,defs",
            "-Wl,--version-script,$(location //tensorflow/lite:tflite_version_script.lds)",
        ],
    }),
    per_os_targets = True,
    deps = [
        ":framework",
        ":tflite_exported_symbols.lds",
        ":tflite_version_script.lds",
        "//tensorflow/lite/kernels:builtin_ops_all_linked",
    ],
)

В нём в раздел deps добавляем следующие строки

        "//tensorflow/lite/nnapi:nnapi_lib",
        "//tensorflow/lite/delegates/nnapi:nnapi_delegate",
        "//tensorflow/lite/delegates/gpu:delegate",
        "//tensorflow/lite/delegates/gpu:gl_delegate",

После чего компилируем библиотеку.
Если при компиляции вам выдаётся ошибка про дублирование переменной(в последних моделях tensorflow), то закоментируйте строку
"//tensorflow/lite/kernels:builtin_ops_all_linked",