Compila tu propia API de Task

La biblioteca de tareas de TensorFlow Lite brinda las APIs de C++, iOS y Android, además de la misma infraestructura que abstrae TensorFlow. Puedes extender la infraestructura de la API Task para compilar APIs personalizadas si tu modelo no es compatible con las bibliotecas Task existentes.

Descripción general

La infraestructura de Task API tiene una estructura de dos capas: la capa C++ inferior. que encapsulan el entorno de ejecución de TFLite y la capa superior de Java/ObjC se comunica con la capa C++ a través de JNI o wrapper.

Implementar la lógica de TensorFlow solo en C++ minimiza el costo, maximiza el rendimiento de la inferencia y simplifica el flujo de trabajo general en todas las plataformas.

Para crear una clase Task, extiende el BaseTaskApi Para proporcionar la lógica de conversión entre la interfaz del modelo de TFLite y la API de Task y, luego, usarás las utilidades Java/ObjC para crear las APIs correspondientes. Con todos los detalles de TensorFlow están ocultos, puedes implementar el modelo TFLite en tus apps sin conocimientos de aprendizaje automático.

TensorFlow Lite proporciona algunas APIs compiladas previamente para las API más populares Vision and PLN Tasks. Puedes crear tus propias APIs para otras tareas con la infraestructura de la API Task.

prebuilt_task_apis
Figura 1: APIs de Tasks compiladas previamente

Compila tu propia API con la infraestructura de la API de Task

API de C++

Todos los detalles de TFLite se implementan en la API de C++. Crea un objeto de la API de las siguientes maneras: con una de las funciones de fábrica y obtener resultados del modelo llamando a las funciones definidos en la interfaz.

Ejemplo de uso

Este es un ejemplo en el que se usa C++ BertQuestionAnswerer para 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

Compila la API

native_task_api
Figura 2: API de Native Task

Para compilar un objeto de API,debes brindar la siguiente información extendiendo BaseTaskApi

  • Determinar la E/S de la API: Tu API debería exponer entradas y salidas similares en diferentes plataformas. p.ej., BertQuestionAnswerer toma dos cadenas (std::string& context, std::string& question) como entrada y genera un vector de posibles respuestas y probabilidades como std::vector<QaAnswer>. Esta se hace especificando los tipos correspondientes en el archivo BaseTaskApi parámetro de plantilla. Con los parámetros de plantilla especificados, el BaseTaskApi::Infer tendrá los tipos de entrada/salida correctos. Esta función puede ser directamente los clientes de API, pero es una buena práctica unirla una función específica del modelo, en este caso, 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();
      }
    }
    
  • Proporcionar la lógica de conversión entre la E/S de la API y el tensor de entrada y salida del Model: Con los tipos de entrada y salida especificados, las subclases también deben implementar las funciones escritas BaseTaskApi::Preprocess y BaseTaskApi::Postprocess. Las dos funciones proporcionan entradas y resultados desde el FlatBuffer de TFLite. La subclase se encarga de asignar de E/S de la API a los tensores de E/S. Ver la implementación completa ejemplo en 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;
      }
    }
    
  • Crea funciones de fábrica de la API: un archivo de modelo y un OpResolver necesarios para inicializar tflite::Interpreter. TaskAPIFactory proporciona funciones de utilidad para crear instancias de BaseTaskApi.

    También debes proporcionar cualquier archivo asociado con el modelo. p.ej., BertQuestionAnswerer también puede tener un archivo adicional para el token de su tokenizador vocabulario.

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

API de Android

Crea APIs de Android definiendo la interfaz de Java/Kotlin y delegando la lógica a la capa de C++ a través de JNI. La API de Android requiere que primero se compile una API nativa.

Ejemplo de uso

Aquí hay un ejemplo con Java BertQuestionAnswerer para 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

Compila la API

android_task_api
Figura 3: API de Android Task

Al igual que las APIs nativas, para compilar un objeto de API, el cliente debe proporcionar el siguiente información extendiendo BaseTaskApi: que proporciona controles de JNI para todas las APIs de tareas de Java.

  • Determinar la E/S de la API: Por lo general, esto refleja las interfaces nativas. p.ej., BertQuestionAnswerer toma (String context, String question) como entrada y genera List<QaAnswer>. La implementación llama a un modelo nativo privado función con firma similar, excepto que tiene un parámetro adicional long nativeHandle, que es el puntero que muestra 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 funciones de fábrica de la API: Esto también refleja la fábrica nativa. de fábrica, excepto que las funciones de fábrica de Android también deben tomar Context para acceder a los archivos. La implementación llama a una de las utilidades del TaskJniUtils para compilar el objeto de la API de C++ correspondiente y pasar su puntero al 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);
    
      }
    
  • Implementa el módulo JNI para funciones nativas: Todos los métodos nativos de Java. se implementan llamando a la función nativa correspondiente desde la JNI módulo. Las funciones de fábrica crearían un objeto de API nativo y mostrarían su puntero como tipo long a Java. En las llamadas posteriores a la API de Java, el puntero de tipo se envía de vuelta a JNI y se transmite de vuelta al objeto de la API nativa. Los resultados de la API nativa luego se convierten de nuevo en resultados de Java.

    Por ejemplo, así es como bert_question_answerer_jni cuando se implementa un plan.

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

Crear APIs de iOS uniendo un objeto de API nativa a un objeto de la API de ObjC El el objeto de API creado se puede usar en ObjC o Swift. La API de iOS requiere la API nativa que se compilará primero.

Ejemplo de uso

Este es un ejemplo con ObjC TFLBertQuestionAnswerer para MobileBert en 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

Compila la API

ios_task_api
Figura 4: API de tareas de iOS

La API de iOS es un wrapper de ObjC simple además de la API nativa. Compila la API de las siguientes maneras: siguiendo estos pasos:

  • Definir el wrapper ObjC: Define una clase ObjC y delega al objeto de la API nativa correspondiente. Ten en cuenta el modelo las dependencias solo pueden aparecer en un archivo .mm debido a la incapacidad de Swift para interoperabilidad con C++.

    • Archivo .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:));
    }
    
    • Archivo .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];
      }
    }