Создайте свой собственный Task API

Библиотека задач TensorFlow Lite предоставляет готовые API-интерфейсы C++, Android и iOS поверх той же инфраструктуры, которая абстрагирует TensorFlow. Вы можете расширить инфраструктуру API задач для создания настраиваемых API, если ваша модель не поддерживается существующими библиотеками задач.

Обзор

Инфраструктура Task API имеет двухуровневую структуру: нижний уровень C++, инкапсулирующий среду выполнения TFLite, и верхний уровень Java/ObjC, который взаимодействует с уровнем C++ через JNI или оболочку.

Реализация всей логики TensorFlow только на C++ минимизирует затраты, максимизирует производительность вывода и упрощает общий рабочий процесс на разных платформах.

Чтобы создать класс Task, расширьте BaseTaskApi , чтобы обеспечить логику преобразования между интерфейсом модели TFLite и интерфейсом Task API, а затем используйте утилиты Java/ObjC для создания соответствующих API. Поскольку все детали TensorFlow скрыты, вы можете развернуть модель TFLite в своих приложениях без каких-либо знаний в области машинного обучения.

TensorFlow Lite предоставляет несколько готовых API для большинства популярных задач Vision и NLP . Вы можете создавать свои собственные API для других задач, используя инфраструктуру Task API.

prebuilt_task_apis
Рисунок 1. Готовые API задач

Создайте свой собственный API с помощью Task API ниже.

С++ API

Все детали TFLite реализованы в C++ API. Создайте объект API, используя одну из фабричных функций, и получите результаты модели, вызвав функции, определенные в интерфейсе.

Пример использования

Вот пример использования C++ BertQuestionAnswerer для MobileBert .

  char kBertModelPath[] = "path/to/model.tflite";
  // Create the API from a model file
  std::unique_ptr<BertQuestionAnswerer> question_answerer =
      BertQuestionAnswerer::CreateFromFile(kBertModelPath);

  char kContext[] = ...; // context of a question to be answered
  char kQuestion[] = ...; // question to be answered
  // ask a question
  std::vector<QaAnswer> answers = question_answerer.Answer(kContext, kQuestion);
  // answers[0].text is the best answer

Создание API

Native_task_api
Рисунок 2. Собственный API задач

Чтобы создать объект API, вы должны предоставить следующую информацию, расширив BaseTaskApi

  • Определите ввод-вывод API . Ваш API должен предоставлять одинаковый ввод/вывод на разных платформах. например, BertQuestionAnswerer принимает две строки (std::string& context, std::string& question) в качестве входных данных и выводит вектор возможных ответов и вероятностей в виде std::vector<QaAnswer> . Это делается путем указания соответствующих типов в параметре шаблона BaseTaskApi . Если указаны параметры шаблона, функция BaseTaskApi::Infer будет иметь правильные типы ввода/вывода. Клиенты API могут напрямую вызывать эту функцию, но рекомендуется обернуть ее внутри функции, специфичной для модели, в данном случае BertQuestionAnswerer::Answer .

    class BertQuestionAnswerer : public BaseTaskApi<
                                  std::vector<QaAnswer>, // OutputType
                                  const std::string&, const std::string& // InputTypes
                                  > {
      // Model specific function delegating calls to BaseTaskApi::Infer
      std::vector<QaAnswer> Answer(const std::string& context, const std::string& question) {
        return Infer(context, question).value();
      }
    }
    
  • Обеспечьте логику преобразования между вводом-выводом API и тензором ввода-вывода модели . Если указаны типы ввода и вывода, подклассы также должны реализовать типизированные функции BaseTaskApi::Preprocess и BaseTaskApi::Postprocess . Эти две функции предоставляют входные и выходные данные из TFLite FlatBuffer . Подкласс отвечает за присвоение значений из ввода-вывода API тензорам ввода-вывода. Полный пример реализации см. в BertQuestionAnswerer .

    class BertQuestionAnswerer : public BaseTaskApi<
                                  std::vector<QaAnswer>, // OutputType
                                  const std::string&, const std::string& // InputTypes
                                  > {
      // Convert API input into tensors
      absl::Status BertQuestionAnswerer::Preprocess(
        const std::vector<TfLiteTensor*>& input_tensors, // input tensors of the model
        const std::string& context, const std::string& query // InputType of the API
      ) {
        // Perform tokenization on input strings
        ...
        // Populate IDs, Masks and SegmentIDs to corresponding input tensors
        PopulateTensor(input_ids, input_tensors[0]);
        PopulateTensor(input_mask, input_tensors[1]);
        PopulateTensor(segment_ids, input_tensors[2]);
        return absl::OkStatus();
      }
    
      // Convert output tensors into API output
      StatusOr<std::vector<QaAnswer>> // OutputType
      BertQuestionAnswerer::Postprocess(
        const std::vector<const TfLiteTensor*>& output_tensors, // output tensors of the model
      ) {
        // Get start/end logits of prediction result from output tensors
        std::vector<float> end_logits;
        std::vector<float> start_logits;
        // output_tensors[0]: end_logits FLOAT[1, 384]
        PopulateVector(output_tensors[0], &end_logits);
        // output_tensors[1]: start_logits FLOAT[1, 384]
        PopulateVector(output_tensors[1], &start_logits);
        ...
        std::vector<QaAnswer::Pos> orig_results;
        // Look up the indices from vocabulary file and build results
        ...
        return orig_results;
      }
    }
    
  • Создайте фабричные функции API . Для инициализации tflite::Interpreter необходимы файл модели и OpResolver . TaskAPIFactory предоставляет служебные функции для создания экземпляров BaseTaskApi.

    Вы также должны предоставить все файлы, связанные с моделью. например, BertQuestionAnswerer также может иметь дополнительный файл для словаря своего токенизатора.

    class BertQuestionAnswerer : public BaseTaskApi<
                                  std::vector<QaAnswer>, // OutputType
                                  const std::string&, const std::string& // InputTypes
                                  > {
      // Factory function to create the API instance
      StatusOr<std::unique_ptr<QuestionAnswerer>>
      BertQuestionAnswerer::CreateBertQuestionAnswerer(
          const std::string& path_to_model, // model to passed to TaskApiFactory
          const std::string& path_to_vocab  // additional model specific files
      ) {
        // Creates an API object by calling one of the utils from TaskAPIFactory
        std::unique_ptr<BertQuestionAnswerer> api_to_init;
        ASSIGN_OR_RETURN(
            api_to_init,
            core::TaskAPIFactory::CreateFromFile<BertQuestionAnswerer>(
                path_to_model,
                absl::make_unique<tflite::ops::builtin::BuiltinOpResolver>(),
                kNumLiteThreads));
    
        // Perform additional model specific initializations
        // In this case building a vocabulary vector from the vocab file.
        api_to_init->InitializeVocab(path_to_vocab);
        return api_to_init;
      }
    }
    

Android API

Создайте API-интерфейсы Android, определив интерфейс Java/Kotlin и делегировав логику уровню C++ через JNI. Android API требует, чтобы сначала был создан собственный API.

Пример использования

Вот пример использования Java BertQuestionAnswerer для MobileBert .

  String BERT_MODEL_FILE = "path/to/model.tflite";
  String VOCAB_FILE = "path/to/vocab.txt";
  // Create the API from a model file and vocabulary file
    BertQuestionAnswerer bertQuestionAnswerer =
        BertQuestionAnswerer.createBertQuestionAnswerer(
            ApplicationProvider.getApplicationContext(), BERT_MODEL_FILE, VOCAB_FILE);

  String CONTEXT = ...; // context of a question to be answered
  String QUESTION = ...; // question to be answered
  // ask a question
  List<QaAnswer> answers = bertQuestionAnswerer.answer(CONTEXT, QUESTION);
  // answers.get(0).text is the best answer

Создание API

android_task_api
Рисунок 3. API задач Android.

Как и в случае с собственными API, для создания объекта API клиенту необходимо предоставить следующую информацию путем расширения BaseTaskApi , которое обеспечивает обработку JNI для всех API-интерфейсов задач Java.

  • Определите ввод-вывод API . Обычно это отражает собственные интерфейсы. например, BertQuestionAnswerer принимает (String context, String question) в качестве входных данных и выводит List<QaAnswer> . Реализация вызывает частную собственную функцию с аналогичной сигнатурой, за исключением того, что она имеет дополнительный параметр long nativeHandle , который является указателем, возвращаемым из C++.

    class BertQuestionAnswerer extends BaseTaskApi {
      public List<QaAnswer> answer(String context, String question) {
        return answerNative(getNativeHandle(), context, question);
      }
    
      private static native List<QaAnswer> answerNative(
                                            long nativeHandle, // C++ pointer
                                            String context, String question // API I/O
                                           );
    
    }
    
  • Создайте фабричные функции API . Это также отражает собственные фабричные функции, за исключением того, что фабричные функции Android также должны использовать Context для доступа к файлам. Реализация вызывает одну из утилит TaskJniUtils для создания соответствующего объекта API C++ и передачи его указателя конструктору BaseTaskApi .

      class BertQuestionAnswerer extends BaseTaskApi {
        private static final String BERT_QUESTION_ANSWERER_NATIVE_LIBNAME =
                                                  "bert_question_answerer_jni";
    
        // Extending super constructor by providing the
        // native handle(pointer of corresponding C++ API object)
        private BertQuestionAnswerer(long nativeHandle) {
          super(nativeHandle);
        }
    
        public static BertQuestionAnswerer createBertQuestionAnswerer(
                                            Context context, // Accessing Android files
                                            String pathToModel, String pathToVocab) {
          return new BertQuestionAnswerer(
              // The util first try loads the JNI module with name
              // BERT_QUESTION_ANSWERER_NATIVE_LIBNAME, then opens two files,
              // converts them into ByteBuffer, finally ::initJniWithBertByteBuffers
              // is called with the buffer for a C++ API object pointer
              TaskJniUtils.createHandleWithMultipleAssetFilesFromLibrary(
                  context,
                  BertQuestionAnswerer::initJniWithBertByteBuffers,
                  BERT_QUESTION_ANSWERER_NATIVE_LIBNAME,
                  pathToModel,
                  pathToVocab));
        }
    
        // modelBuffers[0] is tflite model file buffer, and modelBuffers[1] is vocab file buffer.
        // returns C++ API object pointer casted to long
        private static native long initJniWithBertByteBuffers(ByteBuffer... modelBuffers);
    
      }
    
  • Реализуйте модуль JNI для собственных функций . Все собственные методы Java реализуются путем вызова соответствующей встроенной функции из модуля JNI. Фабричные функции создадут собственный объект API и вернут его указатель в виде длинного типа в Java. При более поздних вызовах API Java указатель длинного типа передается обратно в JNI и возвращается к собственному объекту API. Результаты собственного API затем преобразуются обратно в результаты Java.

    Например, вот как реализован bert_question_answerer_jni .

      // Implements BertQuestionAnswerer::initJniWithBertByteBuffers
      extern "C" JNIEXPORT jlong JNICALL
      Java_org_tensorflow_lite_task_text_qa_BertQuestionAnswerer_initJniWithBertByteBuffers(
          JNIEnv* env, jclass thiz, jobjectArray model_buffers) {
        // Convert Java ByteBuffer object into a buffer that can be read by native factory functions
        absl::string_view model =
            GetMappedFileBuffer(env, env->GetObjectArrayElement(model_buffers, 0));
    
        // Creates the native API object
        absl::StatusOr<std::unique_ptr<QuestionAnswerer>> status =
            BertQuestionAnswerer::CreateFromBuffer(
                model.data(), model.size());
        if (status.ok()) {
          // converts the object pointer to jlong and return to Java.
          return reinterpret_cast<jlong>(status->release());
        } else {
          return kInvalidPointer;
        }
      }
    
      // Implements BertQuestionAnswerer::answerNative
      extern "C" JNIEXPORT jobject JNICALL
      Java_org_tensorflow_lite_task_text_qa_BertQuestionAnswerer_answerNative(
      JNIEnv* env, jclass thiz, jlong native_handle, jstring context, jstring question) {
      // Convert long to native API object pointer
      QuestionAnswerer* question_answerer = reinterpret_cast<QuestionAnswerer*>(native_handle);
    
      // Calls the native API
      std::vector<QaAnswer> results = question_answerer->Answer(JStringToString(env, context),
                                             JStringToString(env, question));
    
      // Converts native result(std::vector<QaAnswer>) to Java result(List<QaAnswerer>)
      jclass qa_answer_class =
        env->FindClass("org/tensorflow/lite/task/text/qa/QaAnswer");
      jmethodID qa_answer_ctor =
        env->GetMethodID(qa_answer_class, "<init>", "(Ljava/lang/String;IIF)V");
      return ConvertVectorToArrayList<QaAnswer>(
        env, results,
        [env, qa_answer_class, qa_answer_ctor](const QaAnswer& ans) {
          jstring text = env->NewStringUTF(ans.text.data());
          jobject qa_answer =
              env->NewObject(qa_answer_class, qa_answer_ctor, text, ans.pos.start,
                             ans.pos.end, ans.pos.logit);
          env->DeleteLocalRef(text);
          return qa_answer;
        });
      }
    
      // Implements BaseTaskApi::deinitJni by delete the native object
      extern "C" JNIEXPORT void JNICALL Java_task_core_BaseTaskApi_deinitJni(
          JNIEnv* env, jobject thiz, jlong native_handle) {
        delete reinterpret_cast<QuestionAnswerer*>(native_handle);
      }
    

iOS API

Создайте API-интерфейсы iOS, обернув собственный объект API в объект API ObjC. Созданный объект API можно использовать как в ObjC, так и в Swift. iOS API требует, чтобы сначала был создан собственный API.

Пример использования

Вот пример использования ObjC TFLBertQuestionAnswerer для MobileBert в Swift.

  static let mobileBertModelPath = "path/to/model.tflite";
  // Create the API from a model file and vocabulary file
  let mobileBertAnswerer = TFLBertQuestionAnswerer.mobilebertQuestionAnswerer(
      modelPath: mobileBertModelPath)

  static let context = ...; // context of a question to be answered
  static let question = ...; // question to be answered
  // ask a question
  let answers = mobileBertAnswerer.answer(
      context: TFLBertQuestionAnswererTest.context, question: TFLBertQuestionAnswererTest.question)
  // answers.[0].text is the best answer

Создание API

ios_task_api
Рисунок 4. API задач iOS.

iOS API — это простая оболочка ObjC поверх собственного API. Создайте API, выполнив следующие действия:

  • Определите оболочку ObjC . Определите класс ObjC и делегируйте реализации соответствующему собственному объекту API. Обратите внимание, что собственные зависимости могут отображаться только в файле .mm из-за неспособности Swift взаимодействовать с C++.

    • .h-файл
      @interface TFLBertQuestionAnswerer : NSObject
    
      // Delegate calls to the native BertQuestionAnswerer::CreateBertQuestionAnswerer
      + (instancetype)mobilebertQuestionAnswererWithModelPath:(NSString*)modelPath
                                                    vocabPath:(NSString*)vocabPath
          NS_SWIFT_NAME(mobilebertQuestionAnswerer(modelPath:vocabPath:));
    
      // Delegate calls to the native BertQuestionAnswerer::Answer
      - (NSArray<TFLQAAnswer*>*)answerWithContext:(NSString*)context
                                         question:(NSString*)question
          NS_SWIFT_NAME(answer(context:question:));
    }
    
    • файл .mm
      using BertQuestionAnswererCPP = ::tflite::task::text::BertQuestionAnswerer;
    
      @implementation TFLBertQuestionAnswerer {
        // define an iVar for the native API object
        std::unique_ptr<QuestionAnswererCPP> _bertQuestionAnswerwer;
      }
    
      // Initialize the native API object
      + (instancetype)mobilebertQuestionAnswererWithModelPath:(NSString *)modelPath
                                              vocabPath:(NSString *)vocabPath {
        absl::StatusOr<std::unique_ptr<QuestionAnswererCPP>> cQuestionAnswerer =
            BertQuestionAnswererCPP::CreateBertQuestionAnswerer(MakeString(modelPath),
                                                                MakeString(vocabPath));
        _GTMDevAssert(cQuestionAnswerer.ok(), @"Failed to create BertQuestionAnswerer");
        return [[TFLBertQuestionAnswerer alloc]
            initWithQuestionAnswerer:std::move(cQuestionAnswerer.value())];
      }
    
      // Calls the native API and converts C++ results into ObjC results
      - (NSArray<TFLQAAnswer *> *)answerWithContext:(NSString *)context question:(NSString *)question {
        std::vector<QaAnswerCPP> results =
          _bertQuestionAnswerwer->Answer(MakeString(context), MakeString(question));
        return [self arrayFromVector:results];
      }
    }