Biblioteca de tareas de TensorFlow Lite

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

Qué esperar de la Biblioteca de tareas

  • APIs limpias y bien definidas que pueden usar los no expertos en AA
    La inferencia se puede realizar con solo 5 líneas de código. Usa la potente y y fáciles de usar en la biblioteca de Tasks como componentes básicos que te ayudarán desarrollar AA con TFLite en dispositivos móviles.

  • Procesamiento de datos complejo pero común
    Admite la lógica común de procesamiento de visión y lenguaje natural para la conversión. entre tus datos y el formato de datos que requiere el modelo. Proporciona lo siguiente: la misma lógica de procesamiento que se puede compartir para el entrenamiento y la inferencia.

  • Aumento del alto rendimiento
    El procesamiento de datos no llevaría más de unos pocos milisegundos, lo que garantizaría de inferencia rápida con TensorFlow Lite.

  • Extensibilidad y personalización
    Puedes aprovechar todos los beneficios que proporciona la infraestructura de la Biblioteca de tareas y compilar fácilmente tus propias APIs de inferencia de Android/iOS.

Tareas admitidas

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

Ejecuta la Biblioteca de tareas con delegados

Los delegados habilitan la aceleración de hardware de modelos de TensorFlow Lite aprovechando los aceleradores integrados en el dispositivo, como GPU y Coral Edge TPU. Utilizando para las operaciones de redes neuronales ofrece grandes beneficios en términos de latencia y eficiencia energética. Por ejemplo, las GPU pueden proporcionar hasta 5x acelerar en latencia en dispositivos móviles y la inferencia de las TPU de Coral Edge 10x más rápidas que las CPU de escritorio.

La Biblioteca de tareas ofrece opciones de configuración sencillas y de resguardo que puedes configurar. y usar delegados. Los siguientes aceleradores ahora son compatibles con la API de Task:

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

Ejemplo de uso de GPU en Android y Java

Paso 1: Agrega la biblioteca del complemento de delegado de GPU al build.gradle de tu módulo. archivo:

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: Configura el delegado de GPU en las opciones de tarea mediante BaseOptions. Por ejemplo, puedes configurar la 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 delegado de GPU en el destino de compilación de Bazel, por ejemplo:

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

Paso 2: Configura el delegado de GPU en las opciones de la 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);

Explora más parámetros de configuración avanzados del acelerador aquí.

Ejemplo de uso de Coral Edge TPU en Python

Configura Coral Edge TPU en las opciones de base de la tarea. Por ejemplo, puedes configura 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 de TPU de Coral Edge en tu destino de compilación de Bazel. por ejemplo:

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

Paso 2: Configura Coral Edge TPU en las opciones de tareas. Por ejemplo, puedes establecer 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: Instala el paquete libusb-1.0-0-dev como se muestra a continuación. Si ya está instalada, continúa con el 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: Compila con la siguiente configuración en tu comando de 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.

Prueba la demostración de la CLI de la biblioteca de tareas herramienta con tus dispositivos de Coral Edge TPU. Explora más en Edge TPU previamente entrenado. de extremo a extremo y Edge TPU avanzado de configuración.

Ejemplo del uso del delegado de Core ML en C++

Puedes encontrar un ejemplo completo en Image Classifier Core ML Delegate (Delegado de Core ML del clasificador de imágenes) Probar

Paso 1: Depende del complemento delegado Core ML en el destino de compilación de Bazel, como como:

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

Paso 2: Configura el delegado de Core ML en las opciones de la tarea. Por ejemplo, puedes establecer el delegado de Core ML 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();