Kendi Görev API'nizi oluşturun

TensorFlow Lite Görev Kitaplığı, önceden oluşturulmuş Soyutlayan aynı altyapı üzerine C++, Android ve iOS API'leri TensorFlow. Özelleştirilmiş API'ler oluşturmak için Task API altyapısını genişletebilirsiniz modeliniz mevcut Görev kitaplıkları tarafından desteklenmiyorsa.

Genel Bakış

Görev API'si altyapısı iki katmanlı bir yapıya sahiptir: alt C++ katmanı en iyi performans gösteren Java/ObjC katmanını C++ katmanıyla JNI veya sarmalayıcı aracılığıyla iletişim kurar.

Tüm TensorFlow mantığını yalnızca C++'ta uygulamak, maliyeti en aza indirir, çıkarım performansını artırır ve platformlar genelindeki iş akışını basitleştirir.

Görev sınıfı oluşturmak için BaseTaskApi TFLite model arayüzü ile Task API arasında dönüşüm mantığı sağlamak için arayüzünü, ardından ilgili API'leri oluşturmak için Java/ObjC yardımcı programlarını kullanın. Entegre tüm TensorFlow ayrıntıları gizlidir; TFLite modelini uygulamalarınızda dağıtabilirsiniz öğrenmesi gerekir.

TensorFlow Lite, dünyanın dört bir yanındaki en popüler uygulamalar için Vision ve NLP görevleri. Merchant Center'da diğer görevler için kendi API'lerinizi oluşturabilirsiniz.

prebuilt_task_apis
Şekil 1. Önceden oluşturulmuş Görev API'leri

Task API altyapısıyla kendi API'nizi oluşturun

C++ API'sı

Tüm TFLite ayrıntıları C++ API'ye uygulanır. API nesnesi oluşturma yöntemi fabrika işlevlerinden birini kullanarak ve işlevleri çağırarak model sonuçları elde edin arayüzde tanımlanmıştır.

Örnek kullanım

Burada, C++ BertQuestionAnswerer şunun için: 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'yi oluşturma

native_task_api
Şekil 2. Yerel Görev API'si

API nesnesi oluşturmak için BaseTaskApi

  • API G/Ç'sini belirleyin - API'niz benzer giriş/çıkışı ortaya çıkarmalıdır yardımcı olur. ör. BertQuestionAnswerer iki dize alır (std::string& context, std::string& question) giriş olarak ve çıkış olarak bir std::vector<QaAnswer> olarak olası yanıt ve olasılıkların vektörü. Bu BaseTaskApi öğesinin içinde karşılık gelen türlerin şablon parametresinden emin olun. Şablon parametreleri belirtildiğinde, BaseTaskApi::Infer işlevi doğru giriş/çıkış türlerine sahip olacaktır. Bu fonksiyon, doğrudan çağrılır ancak bunu özel anahtar kelimelere modele özel bir işlevdir (bu örnekte 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();
      }
    }
    
  • model: Giriş ve çıkış türleri belirtildiğinde alt sınıfların da yazılan fonksiyonları uygulama BaseTaskApi::Preprocess ve BaseTaskApi::Postprocess. İki işlev, girişler ve çıktılar (TFLite FlatBuffer). Alt sınıf, değerlerini API I/O'dan G/Ç tensörlerine arasın. Uygulamanın tamamını görün örneği 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;
      }
    }
    
  • API'nin fabrika işlevlerini oluşturma: Bir model dosyası ve OpResolver ilk kullanıma hazırlamak için tflite::Interpreter. TaskAPIFactory BaseTaskApi örnekleri oluşturmak için yardımcı program işlevleri sunar.

    Modelle ilişkili tüm dosyaları da sağlamanız gerekir. ör. BertQuestionAnswerer, jeton oluşturucuları için ek bir dosyaya da sahip olabilir hakkında bilgi edindiniz.

    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

Java/Kotlin arayüzünü tanımlayarak ve mantığı tanımlayarak Android API'leri oluşturun C++ katmanına taşımaya çalışıyor. Android API, öncelikle yerel API'nin oluşturulmasını gerektirir.

Örnek kullanım

Burada, Java'nın kullanıldığı bir BertQuestionAnswerer şunun için: 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'yi oluşturma

android_task_api
Şekil 3. Android Görev API'si

Yerel API'lere benzer şekilde, API nesnesi oluşturmak için istemcinin uzatarak BaseTaskApi tüm Java Görev API'leri için JNI işlemeleri sunar.

  • API G/Ç'sini belirleyin - Bu, genellikle yerel arayüzleri yansıtır. ör. BertQuestionAnswerer, giriş olarak (String context, String question) alır ve List<QaAnswer> çıktısını verir. Uygulama, gizli yereli çağırır işlevi benzer imzaya sahiptir ancak bu işlev, C++'tan döndürülen işaretçi olan long nativeHandle ek parametresine sahiptir.

    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'nin fabrika işlevlerini oluşturma: Bu, yerel fabrikayı da yansıtır. işlevlerinin yanı sıra Android'in fabrika işlevlerinin de Context dosya erişimi için. Bu uygulama, projenin yürütülmesi sırasında TaskJniUtils API nesnesini derlemek ve işaretçisini BaseTaskApi oluşturucu.

      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);
    
      }
    
  • Yerel işlevler için JNI modülünü uygulama: Tüm Java yerel yöntemleri JNI'den karşılık gelen bir yerel işlev çağrılarak uygulanır modülünü kullanabilirsiniz. Fabrika işlevleri yerel bir API nesnesi oluşturur ve uzun bir türü olan Java'yı işaret ediyor. Java API'ye yapılan sonraki çağrılarda type işaretçisi JNI'ye geri gönderilir ve yerel API nesnesine geri döndürülür. Yerel API sonuçları daha sonra tekrar Java sonuçlarına dönüştürülür.

    Örneğin, ekip üyeleri bert_question_answerer_jni yardımcı olur.

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

Yerel API nesnesini ObjC API nesnesine sarmalayarak iOS API'leri oluşturun. İlgili içeriği oluşturmak için kullanılan API nesnesi ObjC veya Swift'te kullanılabilir. iOS API için yerel API'nin kullanılmasıdır.

Örnek kullanım

Aşağıda, ObjC'nin kullanıldığı bir örnek verilmiştir TFLBertQuestionAnswerer MobileBert için hakkında daha fazla bilgi edinin.

  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'yi oluşturma

ios_task_api
Şekil 4. iOS Görev API'sı

iOS API, yerel API'nin üzerindeki basit bir ObjC sarmalayıcıdır. API'yi derleme şu adımları uygulayın:

  • OjC sarmalayıcıyı tanımlayın - Bir ObjC sınıfı tanımlayın ve karşılık gelen yerel API nesnesine uygulama. Yerel reklamları not etme bağımlılıklar yalnızca .mm dosyasında görünebilir. Bunun nedeni, Swift’in C++ ile birlikte kullanabilirsiniz.

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