Biblioteca de tarefas do TensorFlow Lite

A TensorFlow Lite Task Library contém um conjunto de recursos avançados e fáceis de usar bibliotecas específicas de tarefas para desenvolvedores de apps criarem experiências de ML com o TFLite. Ele fornece interfaces de modelo prontas para uso otimizadas para machine learning conhecido tarefas, como classificação de imagens, perguntas e respostas etc. O modelo são projetadas especificamente para que cada tarefa atinja a melhor desempenho e usabilidade. A Biblioteca de tarefas funciona em várias plataformas e tem suporte em Java, C++ e Swift.

O que esperar da Biblioteca de tarefas

  • APIs limpas e bem definidas que podem ser usadas por não especialistas em ML
    A inferência pode ser feita com apenas cinco linhas de código. Use as ferramentas poderosas APIs fáceis de usar da biblioteca de tarefas como elementos básicos para ajudá-lo desenvolver ML com o TFLite em dispositivos móveis.

  • Processamento de dados complexo, mas comum
    Oferece suporte à lógica comum de processamento de linguagem natural e visão comum para converter entre os dados e o formato de dados exigido pelo modelo. Oferece a mesma lógica de processamento compartilhável para treinamento e inferência.

  • Ganho de alto desempenho
    O processamento de dados não levaria mais do que alguns milissegundos, garantindo que de inferência rápida usando o TensorFlow Lite.

  • Extensibilidade e personalização
    Aproveite todos os benefícios que a infraestrutura da Biblioteca de tarefas oferece e crie facilmente suas próprias APIs de inferência do Android/iOS.

Tarefas compatíveis

Confira abaixo a lista dos tipos de tarefa compatíveis. Espera-se que a lista aumente continuamos permitindo cada vez mais casos de uso.

Executar a biblioteca de tarefas com delegados

Os delegados ativam a aceleração de hardware de Modelos do TensorFlow Lite usando aceleradores no dispositivo, como o GPU e TPU Coral Edge. Utilizando para operações de rede neural, o que oferece enormes benefícios em termos de latência e eficiência energética. Por exemplo, as GPUs podem fornecer uma velocidade de até 5x acelerar em latência em dispositivos móveis e inferência de TPUs do Coral Edge 10x mais rápidas do que as CPUs do computador.

A biblioteca de tarefas oferece fácil configuração e opções alternativas para você configurar e usar delegados. Os seguintes aceleradores agora são compatíveis com a API Task:

O suporte para aceleração na API Task Swift / Web será disponibilizado em breve.

Exemplo de uso da GPU no Android em Java

Etapa 1. Adicionar a biblioteca de plug-ins delegados da GPU ao build.gradle do módulo arquivo:

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

Etapa 2. Configure o delegado da GPU nas opções de tarefas por meio BaseOptions (em inglês). Por exemplo, é possível configurar a GPU em ObjectDetector da seguinte maneira:

// 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);

Exemplo de uso da GPU no Android em C++

Etapa 1. Depende do plug-in delegado da GPU no destino de build do Bazel, como:

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

Etapa 2. Configure o delegado da GPU nas opções de tarefas. Por exemplo, configure GPU em BertQuestionAnswerer da seguinte maneira:

// 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);

Conferir configurações mais avançadas do acelerador aqui.

Exemplo de uso da Coral Edge TPU em Python

Configure o Coral Edge TPU nas opções básicas da tarefa. Por exemplo, é possível configure o Coral Edge TPU em ImageClassifier da seguinte maneira:

# 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)

Exemplo de uso da Coral Edge TPU em C++

Etapa 1. Depende do plug-in de delegação do Coral Edge TPU no destino de criação do Bazel, como:

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

Etapa 2. Configure o Coral Edge TPU nas opções de tarefas. Por exemplo, é possível definir configure o Coral Edge TPU em ImageClassifier da seguinte maneira:

// 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();

Etapa 3. Instale o pacote libusb-1.0-0-dev conforme mostrado abaixo. Se já for instalado, pule para a próxima etapa.

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

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

Etapa 4. Compile com as seguintes configurações no 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.

Teste a demonstração da CLI da biblioteca de tarefas ferramenta nos dispositivos Coral Edge TPU. Conheça mais sobre o Edge TPU pré-treinado de ponta e o Edge TPU avançado do Google Cloud.

Exemplo de uso do Core ML Delegate em C++

Confira um exemplo completo em Image Classifier Core ML Delegate teste.

Etapa 1. Depender do plug-in delegado Core ML no destino de build do Bazel, como como:

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

Etapa 2. Configure o delegado do Core ML nas opções da tarefa. Por exemplo, é possível definir o delegado principal do ML em ImageClassifier da seguinte maneira:

// 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();