Biblioteca de tarefas do TensorFlow Lite

A biblioteca de tarefas do TensorFlow Lite contém um conjunto de bibliotecas específicas de tarefas poderosas e fáceis de usar para desenvolvedores de aplicativos criarem experiências de ML com TFLite. Ele fornece interfaces de modelo prontas para uso otimizadas para tarefas populares de aprendizado de máquina, como classificação de imagens, perguntas e respostas, etc. As interfaces de modelo são projetadas especificamente para cada tarefa para obter o melhor desempenho e usabilidade. A Biblioteca de Tarefas funciona em várias plataformas e é compatível com 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 em apenas 5 linhas de código. Use as APIs poderosas e fáceis de usar da biblioteca de tarefas como blocos de construção para ajudá-lo a desenvolver facilmente ML com TFLite em dispositivos móveis.

• Processamento de dados complexo, mas comum
  Suporta visão comum e lógica de processamento de linguagem natural para converter entre seus dados e o formato de dados exigido pelo modelo. Fornece 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 uma experiência de inferência rápida usando o TensorFlow Lite.

• Extensibilidade e personalização
  Você pode aproveitar todos os benefícios que a infraestrutura da biblioteca de tarefas oferece e criar facilmente suas próprias APIs de inferência para Android/iOS.

Tarefas suportadas

Abaixo está a lista dos tipos de tarefas suportadas. Espera-se que a lista cresça à medida que continuamos possibilitando cada vez mais casos de uso.

• APIs de visão

  • Classificador de imagens
  • Detector de objetos
  • Segmentador de imagens
  • Pesquisador de imagens
  • Incorporador de imagens

• APIs de linguagem natural (NL)

  • NLClassificador
  • BertNLClassificador
  • BertQuestionAnswerer
  • Pesquisador de texto
  • TextEmbedder

• APIs de áudio

  • Classificador de Áudio

• APIs personalizadas

  • Amplie a infraestrutura da Task API e crie uma API personalizada .

Execute a biblioteca de tarefas com delegados

Os delegados permitem a aceleração de hardware dos modelos do TensorFlow Lite aproveitando aceleradores no dispositivo, como GPU e Coral Edge TPU . Utilizá-los para operações de rede neural oferece enormes benefícios em termos de latência e eficiência de energia. Por exemplo, as GPUs podem fornecer uma aceleração de até 5x na latência em dispositivos móveis, e as TPUs Coral Edge inferem 10x mais rápido do que as CPUs de desktop.

A Biblioteca de Tarefas fornece configuração fácil e opções alternativas para você configurar e usar delegados. Os seguintes aceleradores agora são suportados na Task API:

• Android
  • GPU : Java/C++
  • NNAPI : Java/C++
  • Hexágono : C++
• Linux/Mac
  • Coral Borda TPU : C++
• iOS
  • Delegado principal de ML : C++

O suporte de aceleração no Task Swift/Web API estará disponível em breve.

Exemplo de uso de GPU no Android em Java

Etapa 1. Adicione a biblioteca de plug-ins delegados da GPU ao arquivo build.gradle do seu 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'
}

Nota: A NNAPI vem com os alvos da Biblioteca de Tarefas para visão, texto e áudio por padrão.

Etapa 2. Configure o delegado GPU nas opções de tarefa por meio de BaseOptions . Por exemplo, você pode configurar a GPU no 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 de GPU no Android em C++

Etapa 1. Depende do plug-in delegado de GPU em seu destino de compilação do Bazel, como:

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

Observação: o destino gpu_plugin é separado do destino delegado da GPU . gpu_plugin envolve o destino do delegado da GPU e pode fornecer proteção de segurança, ou seja, retorno ao caminho da CPU do TFLite em erros de delegação.

Outras opções de delegado incluem:

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

Passo 2. Configure o delegado GPU nas opções de tarefa. Por exemplo, você pode configurar a GPU no 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);

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

Exemplo de uso de Coral Edge TPU em Python

Configure Coral Edge TPU nas opções básicas da tarefa. Por exemplo, você pode configurar o Coral Edge TPU no 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 de Coral Edge TPU em C++

Etapa 1. Depende do plug-in delegado Coral Edge TPU em seu destino de construção do Bazel, como:

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

Passo 2. Configure Coral Edge TPU nas opções de tarefas. Por exemplo, você pode configurar o Coral Edge TPU no 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 abaixo. Se já estiver 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 em seu 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.

Experimente a ferramenta de demonstração Task Library CLI com seus dispositivos Coral Edge TPU. Explore mais sobre os modelos pré-treinados do Edge TPU e as configurações avançadas do Edge TPU .

Exemplo de uso do Core ML Delegate em C++

Um exemplo completo pode ser encontrado em Image Classifier Core ML Delegate Test .

Etapa 1. Depende do plug-in delegado Core ML em seu destino de compilação do Bazel, como:

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

Etapa 2. Configure o Core ML Delegate nas opções de tarefa. Por exemplo, você pode configurar o Core ML Delegate no 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();