Eigene Task API erstellen

Die TensorFlow Lite-Aufgabenbibliothek bietet vordefinierte C++-, Android- und iOS-APIs auf derselben Infrastruktur aufbauen, TensorFlow Sie können die Task API-Infrastruktur erweitern, um benutzerdefinierte APIs zu erstellen. wenn Ihr Modell von vorhandenen Aufgabenbibliotheken nicht unterstützt wird.

Übersicht

Die Task-API-Infrastruktur hat eine zweischichtige Struktur: die untere C++-Ebene. Durch die Kapselung der TFLite-Laufzeit und der obersten Java/ObjC-Schicht, die kommuniziert mit der C++-Schicht über JNI oder Wrapper.

Die Implementierung der gesamten TensorFlow-Logik ausschließlich in C++ spart Kosten, maximiert und vereinfacht den gesamten Workflow plattformübergreifend.

Erweitern Sie zum Erstellen einer Task-Klasse die BaseTaskApi zum Bereitstellen der Konvertierungslogik zwischen der TFLite-Modellschnittstelle und der Task API und erstellen Sie dann mit den Java-/ObjC-Dienstprogrammen die entsprechenden APIs. Mit Wenn alle TensorFlow-Details ausgeblendet sind, können Sie das TFLite-Modell in Ihren Apps bereitstellen. ganz ohne ML-Kenntnisse.

TensorFlow Lite bietet einige vorkonfigurierte APIs für die gängigsten Vision- und NLP-Aufgaben. Sie können eigene APIs für andere Aufgaben in der Task-API-Infrastruktur nutzen.

prebuilt_task_apis
Abbildung 1: Vordefinierte Task APIs

Eigene API mit der Task API-Infrastruktur erstellen

C++-API

Alle TFLite-Details sind in der C++ API implementiert. Erstellen Sie ein API-Objekt durch eine der Factory-Funktionen verwenden und durch Aufrufen von Funktionen Modellergebnisse die in der Benutzeroberfläche definiert wurden.

Verwendungsbeispiel

Hier ist ein Beispiel mit der C++- BertQuestionAnswerer für 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 erstellen

native_task_api
Abbildung 2. Native Task-API

Um ein API-Objekt zu erstellen, müssen Sie folgende Informationen bereitstellen, indem Sie BaseTaskApi

  • API-E/A bestimmen: Ihre API sollte eine ähnliche Ein-/Ausgabe bereitstellen. auf verschiedenen Plattformen. z.B. Für BertQuestionAnswerer werden zwei Strings (std::string& context, std::string& question) als Eingabe und gibt einen Wert aus Vektor der möglichen Antwort und der Wahrscheinlichkeiten als std::vector<QaAnswer>. Dieses werden die entsprechenden Typen im BaseTaskApi-Element Vorlagenparameter. Mit den angegebenen Vorlagenparametern BaseTaskApi::Infer die richtigen Eingabe-/Ausgabetypen hat. Diese Funktion kann direkt von API-Clients aufgerufen, aber es empfiehlt sich, sie in Eine modellspezifische Funktion, in diesem Fall 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();
      }
    }
    
  • Stellen Sie Konvertierungslogik zwischen API-E/A und Eingabe-/Ausgabe-Tensor des model (Modell). Wenn die Eingabe- und Ausgabetypen angegeben sind, müssen die abgeleiteten Klassen auch Folgendes ausführen: die typisierten Funktionen zu implementieren, BaseTaskApi::Preprocess und BaseTaskApi::Postprocess Mit den beiden Funktionen Eingaben und Ausgaben aus TFLite FlatBuffer. Die Unterklasse hat die Aufgabe, von den API-E/A- zu E/A-Tensoren übergeben. Vollständige Implementierung ansehen Beispiel in 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;
      }
    }
    
  • Factory-Funktionen der API erstellen – eine Modelldatei und einen OpResolver werden benötigt, um die tflite::Interpreter TaskAPIFactory stellt Dienstprogrammfunktionen zum Erstellen von BaseTaskApi-Instanzen bereit.

    Außerdem müssen Sie alle mit dem Modell verknüpften Dateien zur Verfügung stellen. z.B. BertQuestionAnswerer kann auch eine zusätzliche Datei für den Tokenizer haben, Vokabular.

    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

Erstellen Sie Android-APIs, indem Sie die Java-/Kotlin-Schnittstelle definieren und die Logik delegieren. über JNI in die C++-Schicht übertragen. Für die Android API muss zuerst eine native API erstellt werden.

Verwendungsbeispiel

Hier ist ein Beispiel mit Java BertQuestionAnswerer für 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 erstellen

android_task_api
Abbildung 3: Android Task-API

Ähnlich wie bei nativen APIs muss der Client zum Erstellen eines API-Objekts zusätzliche Informationen erhalten, indem Sie BaseTaskApi, die JNI-Handhabungen für alle Java Task APIs bietet.

  • API-E/A bestimmen: Diese Einstellung spiegelt normalerweise die nativen Schnittstellen wider. z.B. BertQuestionAnswerer verwendet (String context, String question) als Eingabe und gibt List<QaAnswer> aus. Bei der Implementierung wird eine private native mit ähnlicher Signatur, außer dass sie einen zusätzlichen Parameter long nativeHandle hat, bei dem es sich um den von C++ zurückgegebenen Zeiger handelt.

    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
                                           );
    
    }
    
  • Factory-Funktionen der API erstellen – Dies spiegelt auch die native Factory wider. außer dass Android-Factory-Funktionen auch Context für den Dateizugriff. Die Implementierung ruft eines der Dienstprogramme in TaskJniUtils um das entsprechende C++ API-Objekt zu erstellen und seinen Zeiger an den 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-Modul für native Funktionen implementieren: Alle nativen Java-Methoden werden durch Aufrufen einer entsprechenden nativen Funktion aus der JNI implementiert. -Modul. Die Factory-Funktionen erstellen ein natives API-Objekt und geben seinen Zeiger als Long-Typ in Java. In späteren Aufrufen des Java-APIs wird der lange Wert Typzeiger an JNI zurückgegeben und zurück in das native API-Objekt umgewandelt. Die nativen API-Ergebnisse werden dann wieder in Java-Ergebnisse konvertiert.

    So wird zum Beispiel bert_question_answerer_jni implementiert wird.

      // 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

Erstellen Sie iOS-APIs, indem Sie ein natives API-Objekt in ein ObjC-API-Objekt einbinden. Die API-Objekt kann entweder in ObjC oder Swift verwendet werden. Für die iOS API ist die native API erstellt wird.

Verwendungsbeispiel

Hier ist ein Beispiel mit ObjC TFLBertQuestionAnswerer für 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

API erstellen

ios_task_api
Abbildung 4: iOS Task-API

Die iOS API ist ein einfacher ObjC-Wrapper, der die native API aufsetzt. API erstellen nach indem Sie die folgenden Schritte ausführen:

  • ObjC-Wrapper definieren – Definieren Sie eine ObjC-Klasse und delegieren Sie die in das entsprechende native API-Objekt. Die nativen Anzeigen nur in einer MM-Datei auftauchen, da Swift Interoperabilität mit C++.

    • .h-Datei
      @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-Datei
      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];
      }
    }