Biblioteca de tareas de TensorFlow Lite

La biblioteca de tareas de TensorFlow Lite contiene un conjunto de bibliotecas específicas de tareas potentes y fáciles de usar para que los desarrolladores de aplicaciones creen experiencias de aprendizaje automático con TFLite. Proporciona interfaces de modelo optimizadas listas para usar para tareas populares de aprendizaje automático, como clasificación de imágenes, preguntas y respuestas, etc. Las interfaces de modelo están diseñadas específicamente para cada tarea para lograr el mejor rendimiento y usabilidad. La biblioteca de tareas funciona multiplataforma y es compatible con Java, C++ y Swift.

Qué esperar de la biblioteca de tareas

  • API limpias y bien definidas que pueden utilizar los no expertos en aprendizaje automático
    La inferencia se puede realizar con solo 5 líneas de código. Utilice las API potentes y fáciles de usar de la biblioteca de tareas como componentes básicos para ayudarle a desarrollar fácilmente ML con TFLite en dispositivos móviles.

  • Procesamiento de datos complejo pero común
    Admite visión común y lógica de procesamiento de lenguaje natural para convertir sus datos y el formato de datos requerido por el modelo. Proporciona la misma lógica de procesamiento compartible para entrenamiento e inferencia.

  • Ganancia de alto rendimiento
    El procesamiento de datos no tomaría más de unos pocos milisegundos, lo que garantiza una experiencia de inferencia rápida con TensorFlow Lite.

  • Extensibilidad y personalización
    Puede aprovechar todos los beneficios que ofrece la infraestructura de la biblioteca de tareas y crear fácilmente sus propias API de inferencia para Android/iOS.

Tareas admitidas

A continuación se muestra la lista de los tipos de tareas admitidos. Se espera que la lista crezca a medida que sigamos habilitando más y más casos de uso.

Ejecutar biblioteca de tareas con delegados

Los delegados habilitan la aceleración de hardware de los modelos TensorFlow Lite aprovechando aceleradores en el dispositivo como la GPU y Coral Edge TPU . Utilizarlos para operaciones de redes neuronales proporciona enormes beneficios en términos de latencia y eficiencia energética. Por ejemplo, las GPU pueden proporcionar una aceleración de latencia hasta 5 veces mayor en dispositivos móviles, y las TPU Coral Edge realizan inferencias 10 veces más rápido que las CPU de escritorio.

La biblioteca de tareas proporciona una configuración sencilla y opciones de respaldo para que usted pueda configurar y utilizar delegados. Los siguientes aceleradores ahora son compatibles con la API de tareas:

Próximamente se admitirá la aceleración en Task Swift/Web API.

Ejemplo de uso de GPU en Android en Java

Paso 1. Agregue la biblioteca de complementos delegados de GPU al archivo build.gradle de su módulo:

dependencies {
    // Import Task Library dependency for vision, text, or audio.

    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}

Paso 2. Configure el delegado de GPU en las opciones de tarea a través de BaseOptions . Por ejemplo, puede configurar GPU en ObjectDetector de la siguiente manera:

// Turn on GPU delegation.
BaseOptions baseOptions = BaseOptions.builder().useGpu().build();
// Configure other options in ObjectDetector
ObjectDetectorOptions options =
    ObjectDetectorOptions.builder()
        .setBaseOptions(baseOptions)
        .setMaxResults(1)
        .build();

// Create ObjectDetector from options.
ObjectDetector objectDetector =
    ObjectDetector.createFromFileAndOptions(context, modelFile, options);

// Run inference
List<Detection> results = objectDetector.detect(image);

Ejemplo de uso de GPU en Android en C++

Paso 1. Depende del complemento de delegado de GPU en tu objetivo de compilación de Bazel, como por ejemplo:

deps = [
  "//tensorflow_lite_support/acceleration/configuration:gpu_plugin", # for GPU
]

Otras opciones de delegados incluyen:

"//tensorflow_lite_support/acceleration/configuration:nnapi_plugin", # for NNAPI
"//tensorflow_lite_support/acceleration/configuration:hexagon_plugin", # for Hexagon

Paso 2. Configure el delegado de GPU en las opciones de tarea. Por ejemplo, puedes configurar GPU en BertQuestionAnswerer de la siguiente manera:

// Initialization
BertQuestionAnswererOptions options;
// Load the TFLite model.
auto base_options = options.mutable_base_options();
base_options->mutable_model_file()->set_file_name(model_file);
// Turn on GPU delegation.
auto tflite_settings = base_options->mutable_compute_settings()->mutable_tflite_settings();
tflite_settings->set_delegate(Delegate::GPU);
// (optional) Turn on automatical fallback to TFLite CPU path on delegation errors.
tflite_settings->mutable_fallback_settings()->set_allow_automatic_fallback_on_execution_error(true);

// Create QuestionAnswerer from options.
std::unique_ptr<QuestionAnswerer> answerer = BertQuestionAnswerer::CreateFromOptions(options).value();

// Run inference on GPU.
std::vector<QaAnswer> results = answerer->Answer(context_of_question, question_to_ask);

Explore configuraciones de acelerador más avanzadas aquí .

Ejemplo de uso de Coral Edge TPU en Python

Configura Coral Edge TPU en las opciones base de la tarea. Por ejemplo, puede configurar Coral Edge TPU en ImageClassifier de la siguiente manera:

# Imports
from tflite_support.task import vision
from tflite_support.task import core

# Initialize options and turn on Coral Edge TPU delegation.
base_options = core.BaseOptions(file_name=model_path, use_coral=True)
options = vision.ImageClassifierOptions(base_options=base_options)

# Create ImageClassifier from options.
classifier = vision.ImageClassifier.create_from_options(options)

# Run inference on Coral Edge TPU.
image = vision.TensorImage.create_from_file(image_path)
classification_result = classifier.classify(image)

Ejemplo de uso de Coral Edge TPU en C++

Paso 1. Depende del complemento delegado Coral Edge TPU en tu objetivo de compilación de bazel, como por ejemplo:

deps = [
  "//tensorflow_lite_support/acceleration/configuration:edgetpu_coral_plugin", # for Coral Edge TPU
]

Paso 2. Configure Coral Edge TPU en las opciones de tarea. Por ejemplo, puede configurar Coral Edge TPU en ImageClassifier de la siguiente manera:

// Initialization
ImageClassifierOptions options;
// Load the TFLite model.
options.mutable_base_options()->mutable_model_file()->set_file_name(model_file);
// Turn on Coral Edge TPU delegation.
options.mutable_base_options()->mutable_compute_settings()->mutable_tflite_settings()->set_delegate(Delegate::EDGETPU_CORAL);
// Create ImageClassifier from options.
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::CreateFromOptions(options).value();

// Run inference on Coral Edge TPU.
const ClassificationResult result = image_classifier->Classify(*frame_buffer).value();

Paso 3. Instale el paquete libusb-1.0-0-dev como se muestra a continuación. Si ya está instalado, salte al siguiente paso.

# On the Linux
sudo apt-get install libusb-1.0-0-dev

# On the macOS
port install libusb
# or
brew install libusb

Paso 4. Compile con las siguientes configuraciones en su comando bazel:

# On the Linux
--define darwinn_portable=1 --linkopt=-lusb-1.0

# On the macOS, add '--linkopt=-lusb-1.0 --linkopt=-L/opt/local/lib/' if you are
# using MacPorts or '--linkopt=-lusb-1.0 --linkopt=-L/opt/homebrew/lib' if you
# are using Homebrew.
--define darwinn_portable=1 --linkopt=-L/opt/local/lib/ --linkopt=-lusb-1.0

# Windows is not supported yet.

Pruebe la herramienta de demostración CLI de la biblioteca de tareas con sus dispositivos Coral Edge TPU. Explore más sobre los modelos de Edge TPU previamente entrenados y las configuraciones avanzadas de Edge TPU .

Ejemplo de uso de Core ML Delegate en C++

Puede encontrar un ejemplo completo en Image Classifier Core ML Delegate Test .

Paso 1. Depende del complemento delegado Core ML en tu objetivo de compilación de Bazel, como por ejemplo:

deps = [
  "//tensorflow_lite_support/acceleration/configuration:coreml_plugin", # for Core ML Delegate
]

Paso 2. Configure Core ML Delegate en las opciones de tarea. Por ejemplo, puede configurar Core ML Delegate en ImageClassifier de la siguiente manera:

// Initialization
ImageClassifierOptions options;
// Load the TFLite model.
options.mutable_base_options()->mutable_model_file()->set_file_name(model_file);
// Turn on Core ML delegation.
options.mutable_base_options()->mutable_compute_settings()->mutable_tflite_settings()->set_delegate(::tflite::proto::Delegate::CORE_ML);
// Set DEVICES_ALL to enable Core ML delegation on any device (in contrast to
// DEVICES_WITH_NEURAL_ENGINE which creates Core ML delegate only on devices
// with Apple Neural Engine).
options.mutable_base_options()->mutable_compute_settings()->mutable_tflite_settings()->mutable_coreml_settings()->set_enabled_devices(::tflite::proto::CoreMLSettings::DEVICES_ALL);
// Create ImageClassifier from options.
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::CreateFromOptions(options).value();

// Run inference on Core ML.
const ClassificationResult result = image_classifier->Classify(*frame_buffer).value();