Crea la tua API Task

Analogamente alle API native, per creare un oggetto API, il client deve fornire le seguenti informazioni estendendo BaseTaskApi , che fornisce le gestioni JNI per tutte le API Java Task.

• Determina l'I/O dell'API : in genere rispecchia le interfacce native. ad es BertQuestionAnswerer prende (String context, String question) come input e output List<QaAnswer> . L'implementazione chiama una funzione nativa privata con una firma simile, tranne per il fatto che ha un parametro aggiuntivo long nativeHandle , che è il puntatore restituito da 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
                                         );
  
  }
  

• Crea funzioni di fabbrica dell'API : rispecchia anche le funzioni di fabbrica native, tranne per il fatto che anche le funzioni di fabbrica di Android devono accettare Context per l'accesso ai file. L'implementazione chiama una delle utilità in TaskJniUtils per creare l'oggetto API C++ corrispondente e passare il relativo puntatore al costruttore 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);
  
    }
  

• Implementare il modulo JNI per le funzioni native - Tutti i metodi nativi Java vengono implementati chiamando una funzione nativa corrispondente dal modulo JNI. Le funzioni di fabbrica creerebbero un oggetto API nativo e restituirebbero il suo puntatore come tipo lungo a Java. Nelle successive chiamate all'API Java, il puntatore di tipo lungo viene restituito a JNI e restituito all'oggetto API nativo. I risultati dell'API nativa vengono quindi riconvertiti in risultati Java.

  Ad esempio, ecco come viene implementato 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

Crea API iOS avvolgendo un oggetto API nativo in un oggetto API ObjC. L'oggetto API creato può essere utilizzato in ObjC o Swift. L'API iOS richiede prima la creazione dell'API nativa.

Esempio di utilizzo

Ecco un esempio che utilizza ObjC TFLBertQuestionAnswerer per MobileBert in 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

Costruire l'API

Figura 4. API delle attività iOS

L'API iOS è un semplice wrapper ObjC sopra l'API nativa. Crea l'API seguendo i passaggi seguenti:

• Definisci il wrapper ObjC - Definisci una classe ObjC e delega le implementazioni all'oggetto API nativo corrispondente. Nota che le dipendenze native possono apparire solo in un file .mm a causa dell'incapacità di Swift di interoperare con 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];
    }
  }