Membangun Task API Anda sendiri

Library Tugas TensorFlow Lite menyediakan bawaan API C++, Android, dan iOS di atas infrastruktur sama yang memisahkan TensorFlow. Anda dapat memperluas infrastruktur Task API untuk membangun API yang disesuaikan jika model Anda tidak didukung oleh library Task yang ada.

Ringkasan

Infrastruktur Task API memiliki struktur dua lapisan: lapisan C++ bawah melakukan enkapsulasi runtime TFLite dan lapisan Java/ObjC teratas yang berkomunikasi dengan lapisan C++ melalui JNI atau wrapper.

Mengimplementasikan semua logika TensorFlow hanya di C++ akan meminimalkan biaya dan memaksimalkan performa inferensi dan menyederhanakan seluruh alur kerja di berbagai platform.

Untuk membuat class Task, perluas BaseTaskApi untuk menyediakan logika konversi antara antarmuka model TFLite dan Task API lalu gunakan utilitas Java/ObjC untuk membuat API yang sesuai. Dengan semua detail TensorFlow tersembunyi, Anda bisa men-deploy model TFLite di aplikasi tanpa memerlukan pengetahuan machine learning.

TensorFlow Lite menyediakan beberapa API bawaan untuk sebagian besar Tugas visi dan NLP. Anda dapat membangun API Anda sendiri untuk tugas lain menggunakan infrastruktur Task API.

prebuilt_task_apis
Gambar 1. Task API bawaan

Bangun API Anda sendiri dengan infrastruktur Task API

API C++

Semua detail TFLite diimplementasikan di C++ API. Buat objek API dengan menggunakan salah satu fungsi factory dan mendapatkan hasil model dengan memanggil fungsi yang ditentukan dalam antarmuka.

Contoh penggunaan

Berikut adalah contoh penggunaan C++ BertQuestionAnswerer untuk 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

Membangun API

native_task_api
Gambar 2. API Tugas Native

Untuk membangun objek API,Anda harus menyediakan informasi berikut dengan memperluas BaseTaskApi

  • Menentukan I/O API - API Anda harus mengekspos input/output yang serupa di berbagai platform. mis. BertQuestionAnswerer mengambil dua string (std::string& context, std::string& question) sebagai input dan output vektor yang mungkin dari jawaban dan probabilitas sebagai std::vector<QaAnswer>. Ini dilakukan dengan menentukan jenis yang sesuai dalam BaseTaskApi parameter template. Dengan parameter template yang telah ditentukan, BaseTaskApi::Infer akan memiliki tipe input/output yang benar. Fungsi ini dapat berupa dipanggil langsung oleh klien API, tetapi sebaiknya menggabungkannya di dalam fungsi khusus model, dalam hal ini, 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();
      }
    }
    
  • Berikan logika konversi antara I/O API dan tensor input/output model - Dengan jenis input dan output yang ditentukan, subclass juga perlu mengimplementasikan fungsi yang diketik BaseTaskApi::Preprocess dan BaseTaskApi::Postprocess Kedua fungsi tersebut memberikan input dan output dari FlatBuffer TFLite. Subclass bertanggung jawab untuk menetapkan dari API I/O ke tensor I/O. Lihat implementasi lengkap contoh dalam 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;
      }
    }
    
  • Membuat fungsi factory dari API - File model dan OpResolver diperlukan untuk menginisialisasi tflite::Interpreter TaskAPIFactory menyediakan fungsi utilitas untuk membuat instance BaseTaskApi.

    Anda juga harus menyediakan file apa pun yang terkait dengan model tersebut. misalnya, BertQuestionAnswerer juga dapat memiliki file tambahan untuk tokenizernya kosakata.

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

API Android

Membuat API Android dengan menentukan antarmuka Java/Kotlin dan mendelegasikan logika ke lapisan C++ melalui JNI. Android API mengharuskan API native dibangun terlebih dahulu.

Contoh penggunaan

Berikut ini contoh penggunaan Java BertQuestionAnswerer untuk 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

Membangun API

android_task_api
Gambar 3. Android Task API

Serupa dengan API Native, untuk membangun objek API, klien harus menyediakan informasi berikut dengan memperluas BaseTaskApi, yang menyediakan penanganan JNI untuk semua Java Task API.

  • Menentukan I/O API - Tindakan ini biasanya mencerminkan antarmuka native. mis. BertQuestionAnswerer menggunakan (String context, String question) sebagai input dan menghasilkan List<QaAnswer>. Implementasi ini memanggil native pribadi dengan tanda tangan yang serupa, tetapi memiliki parameter tambahan long nativeHandle, yang merupakan pointer yang ditampilkan dari 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
                                           );
    
    }
    
  • Membuat fungsi factory API - Tindakan ini juga mencerminkan factory native kecuali fungsi {i>factory<i} Android juga perlu Context untuk akses file. Implementasi ini memanggil salah satu utilitas di TaskJniUtils untuk membangun objek C++ API yang sesuai dan meneruskan pointernya ke Konstruktor 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);
    
      }
    
  • Mengimplementasikan modul JNI untuk fungsi native - Semua metode native Java diimplementasikan dengan memanggil fungsi native yang sesuai dari JNI ruang lingkup modul ini. Fungsi factory akan membuat objek API native dan menampilkan pointernya sebagai jenis panjang untuk Java. Dalam panggilan berikutnya ke Java API, type pointer diteruskan kembali ke JNI dan ditransmisikan kembali ke objek API native. Hasil API native kemudian dikonversi kembali ke hasil Java.

    Sebagai contoh, ini adalah cara bert_question_answerer_jni diimplementasikan.

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

API iOS

Buat API iOS dengan menggabungkan objek API native ke dalam objek ObjC API. Tujuan objek API yang dibuat dapat digunakan di ObjC maupun Swift. iOS API memerlukan untuk membuat API native terlebih dahulu.

Contoh penggunaan

Berikut adalah contoh penggunaan ObjC TFLBertQuestionAnswerer untuk MobileBert di 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

Membangun API

ios_task_api
Gambar 4. iOS Task API

API iOS adalah wrapper ObjC sederhana selain API native. Bangun API dengan dengan mengikuti langkah-langkah berikut:

  • Menentukan wrapper ObjC - Tentukan class ObjC dan delegasikan implementasi pada objek API native yang terkait. Perhatikan native dependensi hanya dapat muncul dalam file .mm karena ketidakmampuan Swift untuk dengan C++.

    • File .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:));
    }
    
    • File .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];
      }
    }