בנה משלך ממשימות API

בדומה לממשקי API מקוריים, כדי לבנות אובייקט API, הלקוח צריך לספק את המידע הבא על ידי הרחבת BaseTaskApi , המספקת טיפולי JNI עבור כל ממשקי ה-API של משימות Java.

• קבע את ה-API I/O - זה בדרך כלל משקף את הממשקים המקוריים. לדוגמה 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 - זה גם משקף פונקציות מקוריות של היצרן, למעט פונקציות המפעל של אנדרואיד צריכות לקבל גם 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. בקריאות מאוחרות יותר ל-Java API, מצביע הסוג הארוך מועבר בחזרה ל-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 מקורי לאובייקט של ObjC API. ניתן להשתמש באובייקט ה-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

איור 4. iOS Task API

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