יצירת Tasks API משלכם

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

• קביעת ה-I/O של ה-API – האפשרות הזו בדרך כלל משקף את הממשקים המקוריים. למשל BertQuestionAnswerer לוקח את (String context, String question) כקלט ויוצר את הפלט List<QaAnswer>. ההטמעה קוראת ל-Native נייטיב פרטי עם חתימה דומה, אבל יש בה פרמטר נוסף 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 – הנתונים האלה ישקף גם את ה-Native של היצרן. קיימות, פרט לפונקציות של Android להגדרות המקוריות. Context לגישה לקבצים. ההטמעה קוראת לאחת מהתוכנות TaskJniUtils כדי ליצור את האובייקט התואם של C++ API ולהעביר את הסמן שלו BaseTaskApi constructor.

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

API ל-iOS

כדי ליצור ממשקי API ל-iOS, צריך לתחום את אובייקט ה-API המקורי באובייקט ObjC API. אפשר להשתמש באובייקט ה-API שנוצר ב-ObjC או ב-Swift. ב-iOS API נדרש את ה-API המקורי שצריך לבנות קודם.

דוגמאות לשימוש

הנה דוגמה באמצעות ObjC TFLBertQuestionAnswerer במסגרת MobileBert בסוויפט.

  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. ממשק API למשימות ב-iOS

iOS API הוא wrapper פשוט של ObjC מעל API מקורי. פיתוח ה-API באמצעות באמצעות השלבים הבאים:

• הגדרת wrapper של 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];
    }
  }