Attend the Women in ML Symposium on December 7 Register now

Biblioteca de tareas de TensorFlow Lite

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

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 listas para usar optimizadas 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 a fin de lograr el mejor rendimiento y facilidad de uso. La biblioteca de tareas funciona en varias plataformas y es compatible con Java, C++ y Swift.

Qué esperar de la Biblioteca de tareas

  • API limpias y bien definidas que pueden usar quienes no son expertos en aprendizaje automático
    La inferencia se puede hacer dentro de solo 5 líneas de código. Use las API potentes y fáciles de usar en la biblioteca de tareas como bloques de construcción para ayudarlo a desarrollar fácilmente ML con TFLite en dispositivos móviles.

  • Procesamiento de datos complejo pero común
    Admite lógica de procesamiento de visión común y lenguaje natural para convertir entre 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 proporciona la infraestructura de la biblioteca de tareas y crear fácilmente sus propias API de inferencia de Android/iOS.

Tareas admitidas

A continuación se muestra la lista de los tipos de tareas compatibles. Se espera que la lista crezca a medida que continuamos 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 al aprovechar los aceleradores en el dispositivo, como la GPU y Coral Edge TPU . Utilizarlos para operaciones de redes neuronales brinda enormes beneficios en términos de latencia y eficiencia energética. Por ejemplo, las GPU pueden aumentar hasta 5 veces la latencia en dispositivos móviles, y las TPU de Coral Edge infieren 10 veces más rápido que las CPU de escritorio.

La biblioteca de tareas proporciona una configuración sencilla y opciones alternativas para configurar y utilizar delegados. Los siguientes aceleradores ahora son compatibles con Task API:

El soporte de aceleración en Task Swift / Web API llegará pronto.

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 la tarea a través de BaseOptions . Por ejemplo, puede configurar GPU en ObjectDetecor 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. Dependa del complemento de delegado de GPU en su objetivo de compilación de bazel, como:

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

Otras opciones de delegado 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 la tarea. Por ejemplo, puede 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 más avanzadas del acelerador aquí .

Ejemplo de uso de Coral Edge TPU en Python

Configure 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. Confíe en el complemento de delegado de Coral Edge TPU en su objetivo de compilación de bazel, como:

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

Paso 2. Configure Coral Edge TPU en las opciones de la 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, vaya 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 Edge TPU preentrenados y la configuración avanzada 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. Dependa del complemento delegado de Core ML en su objetivo de compilación de bazel, como:

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

Paso 2. Configure Core ML Delegate en las opciones de la 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();