La biblioteca de tareas de TensorFlow Lite proporciona API nativas/Android/iOS prediseñadas sobre la misma infraestructura que abstrae TensorFlow. Puede ampliar la infraestructura de Task API para crear API personalizadas si su modelo no es compatible con las bibliotecas de Task existentes.
Descripción general
La infraestructura de Task API tiene una estructura de dos capas: la capa inferior de C++ que encapsula el tiempo de ejecución nativo de TFLite y la capa superior de Java/ObjC que se comunica con la capa de C++ a través de JNI o contenedor nativo.
La implementación de toda 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, extienda BaseTaskApi para proporcionar lógica de conversión entre la interfaz del modelo TFLite y la interfaz Task API, luego use las utilidades Java/ObjC para crear las API correspondientes. Con todos los detalles de TensorFlow ocultos, puedes implementar el modelo TFLite en tus aplicaciones sin ningún conocimiento de aprendizaje automático.
TensorFlow Lite proporciona algunas API prediseñadas para las tareas más populares de Vision y PNL . Puede crear sus propias API para otras tareas utilizando la infraestructura de Task API.
Cree su propia API con Task API infra
API C++
Todos los detalles de TFLite se implementan en la API nativa. Cree un objeto API utilizando una de las funciones de fábrica y obtenga resultados del modelo llamando a las funciones definidas en la interfaz.
Uso de muestra
A continuación se muestra un ejemplo que utiliza 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
Construyendo la API
Para crear un objeto API, debe proporcionar la siguiente información extendiendo BaseTaskApi
Determine la E/S de API : su API debe exponer entradas/salidas similares en diferentes plataformas. por ejemplo,
BertQuestionAnswerer
toma dos cadenas(std::string& context, std::string& question)
como entrada y genera un vector de posibles respuestas y probabilidades comostd::vector<QaAnswer>
. Esto se hace especificando los tipos correspondientes en el parámetro de plantilla deBaseTaskApi
. Con los parámetros de plantilla especificados, la funciónBaseTaskApi::Infer
tendrá los tipos de entrada/salida correctos. Los clientes API pueden llamar directamente a esta función, pero es una buena práctica incluirla dentro de 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 lógica de conversión entre E/S de API y el tensor de entrada/salida del modelo : con los tipos de entrada y salida especificados, las subclases también deben implementar las funciones escritas
BaseTaskApi::Preprocess
yBaseTaskApi::Postprocess
. Las dos funciones proporcionan entradas y salidas del TFLiteFlatBuffer
. La subclase es responsable de asignar valores desde la E/S de API a los tensores de E/S. Vea el ejemplo de implementación completo enBertQuestionAnswerer
.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; } }
Cree funciones de fábrica de la API : se necesitan un archivo de modelo y un
OpResolver
para inicializartflite::Interpreter
.TaskAPIFactory
proporciona funciones de utilidad para crear instancias de BaseTaskApi.También debe proporcionar los archivos asociados con el modelo. por ejemplo,
BertQuestionAnswerer
también puede tener un archivo adicional para el vocabulario de su tokenizador.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
Cree API de Android definiendo la interfaz Java/Kotlin y delegando la lógica a la capa C++ a través de JNI. La API de Android requiere que se cree primero una API nativa.
Uso de muestra
A continuación se muestra un ejemplo que utiliza 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
Construyendo la API
De manera similar a las API nativas, para crear un objeto API, el cliente debe proporcionar la siguiente información extendiendo BaseTaskApi
, que proporciona manejo JNI para todas las API de tareas Java.
Determine la E/S de API : esto generalmente refleja las interfaces nativas. por ejemplo,
BertQuestionAnswerer
toma(String context, String question)
como entrada y salidaList<QaAnswer>
. La implementación llama a una función nativa privada con una firma similar, excepto que tiene un parámetro adicionallong nativeHandle
, que es el puntero devuelto desde 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 ); }
Crear funciones de fábrica de la API : esto también refleja las funciones de fábrica nativas, excepto que las funciones de fábrica de Android también necesitan tomar
Context
para el acceso a archivos. La implementación llama a una de las utilidades deTaskJniUtils
para crear el objeto API de C++ correspondiente y pasar su puntero al constructorBaseTaskApi
.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); }
Implemente el módulo JNI para funciones nativas : todos los métodos nativos de Java se implementan llamando a una función nativa correspondiente desde el módulo JNI. Las funciones de fábrica crearían un objeto API nativo y devolverían su puntero como un tipo largo a Java. En llamadas posteriores a la API de Java, el puntero de tipo largo se devuelve a JNI y se devuelve al objeto API nativo. Los resultados de la API nativa luego se vuelven a convertir en resultados de Java.
Por ejemplo, así es como se implementa 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 de iOS
Cree API de iOS envolviendo un objeto API nativo en un objeto API ObjC. El objeto API creado se puede utilizar en ObjC o Swift. La API de iOS requiere que primero se cree la API nativa.
Uso de muestra
A continuación se muestra un ejemplo que utiliza 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
Construyendo la API
La API de iOS es un contenedor ObjC simple además de la API nativa. Cree la API siguiendo los pasos a continuación:
Defina el contenedor ObjC : defina una clase ObjC y delegue las implementaciones al objeto API nativo correspondiente. Tenga en cuenta que las dependencias nativas solo pueden aparecer en un archivo .mm debido a la incapacidad de Swift para interoperar 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]; } }
A menos que se indique lo contrario, el contenido de esta página está sujeto a la licencia Reconocimiento 4.0 de Creative Commons y las muestras de código están sujetas a la licencia Apache 2.0. Para obtener más información, consulta las políticas del sitio web de Google Developers. Java es una marca registrada de Oracle o sus afiliados.
Última actualización: 2024-06-28 (UTC).