Biblioteka zadań TensorFlow Lite

Biblioteka zadań TensorFlow Lite zawiera zestaw wydajnych i łatwych w użyciu bibliotek specyficznych dla zadań dla twórców aplikacji, umożliwiających tworzenie doświadczeń ML za pomocą TFLite. Zapewnia zoptymalizowane, gotowe do użycia interfejsy modeli do popularnych zadań uczenia maszynowego, takich jak klasyfikacja obrazów, pytania i odpowiedzi itp. Interfejsy modeli są specjalnie zaprojektowane dla każdego zadania, aby osiągnąć najlepszą wydajność i użyteczność. Biblioteka zadań działa na wielu platformach i jest obsługiwana w językach Java, C++ i Swift.

Czego można się spodziewać po bibliotece zadań

• Czyste i dobrze zdefiniowane interfejsy API, z których mogą korzystać osoby niebędące ekspertami w dziedzinie uczenia maszynowego
  Wnioskowanie można przeprowadzić w zaledwie 5 linijkach kodu. Użyj wydajnych i łatwych w użyciu interfejsów API w bibliotece zadań jako elementów ułatwiających tworzenie systemów uczenia maszynowego za pomocą TFLite na urządzeniach mobilnych.

• Złożone, ale powszechne przetwarzanie danych
  Obsługuje wspólną wizję i logikę przetwarzania języka naturalnego w celu konwersji danych na format danych wymagany przez model. Zapewnia tę samą, współdzieloną logikę przetwarzania na potrzeby uczenia i wnioskowania.

• Wysoki wzrost wydajności
  Przetwarzanie danych zajmie nie więcej niż kilka milisekund, zapewniając szybkie wnioskowanie przy użyciu TensorFlow Lite.

• Rozszerzalność i dostosowywanie
  Możesz wykorzystać wszystkie zalety infrastruktury biblioteki zadań i łatwo zbudować własne interfejsy API wnioskowania dla systemu Android/iOS.

Obsługiwane zadania

Poniżej znajduje się lista obsługiwanych typów zadań. Oczekuje się, że lista będzie się powiększać w miarę udostępniania coraz większej liczby przypadków użycia.

• Wizja API

  • Klasyfikator obrazu
  • Detektor obiektów
  • Segmentator obrazów
  • Wyszukiwarka obrazów
  • ImageEmbedder

• Interfejsy API języka naturalnego (NL).

  • NLClassifier
  • BertNLClassifier
  • BertOdpowiedź na pytanie
  • Wyszukiwarka tekstu
  • TextEmbedder

• Interfejsy API dźwięku

  • Klasyfikator audio

• Niestandardowe interfejsy API

  • Rozszerzaj infrastrukturę Task API i twórz niestandardowe API .

Uruchom bibliotekę zadań z delegatami

Delegaci umożliwiają sprzętową akcelerację modeli TensorFlow Lite poprzez wykorzystanie akceleratorów wbudowanych w urządzenia, takich jak procesor graficzny i TPU Coral Edge . Wykorzystanie ich do operacji sieci neuronowych zapewnia ogromne korzyści w zakresie opóźnień i wydajności energetycznej. Na przykład procesory graficzne mogą zapewnić nawet 5-krotne przyspieszenie opóźnień na urządzeniach mobilnych, a procesory TPU Coral Edge wnioskowują 10 razy szybciej niż procesory do komputerów stacjonarnych.

Biblioteka zadań zapewnia łatwą konfigurację i opcje awaryjne umożliwiające skonfigurowanie delegatów i korzystanie z nich. W interfejsie Task API obsługiwane są teraz następujące akceleratory:

• Android
  • Karta graficzna : Java/C++
  • NNAPI : Java/C++
  • Sześciokąt : C++
• Linux/Mac
  • Coral Edge TPU : C++
• iOS
  • Delegat Core ML : C++

Obsługa akceleracji w Task Swift / Web API już wkrótce.

Przykładowe wykorzystanie GPU na Androidzie w Javie

Krok 1. Dodaj bibliotekę wtyczek delegowania GPU do pliku build.gradle swojego modułu:

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

Uwaga: NNAPI domyślnie zawiera cele Biblioteki zadań dotyczące obrazu, tekstu i dźwięku.

Krok 2. Skonfiguruj delegata GPU w opcjach zadania poprzez BaseOptions . Na przykład możesz skonfigurować procesor graficzny w ObjectDetector w następujący sposób:

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

Przykładowe użycie GPU na Androidzie w C++

Krok 1. Zależnie od wtyczki delegowania GPU w docelowym miejscu kompilacji Bazel, na przykład:

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

Uwaga: cel gpu_plugin jest odrębny od celu delegata GPU . gpu_plugin otacza cel delegowania GPU i może zapewnić zabezpieczenie, tj. powrót do ścieżki procesora TFLite w przypadku błędów delegowania.

Inne opcje delegowania obejmują:

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

Krok 2. Skonfiguruj delegata GPU w opcjach zadania. Na przykład możesz skonfigurować procesor graficzny w BertQuestionAnswerer w następujący sposób:

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

Tutaj możesz zapoznać się z bardziej zaawansowanymi ustawieniami akceleratora.

Przykładowe wykorzystanie Coral Edge TPU w Pythonie

Skonfiguruj Coral Edge TPU w podstawowych opcjach zadania. Na przykład możesz skonfigurować Coral Edge TPU w ImageClassifier w następujący sposób:

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

Przykładowe wykorzystanie Coral Edge TPU w C++

Krok 1. Polegaj na wtyczce delegowania TPU Coral Edge w docelowym miejscu kompilacji Bazel, na przykład:

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

Krok 2. Skonfiguruj Coral Edge TPU w opcjach zadania. Na przykład możesz skonfigurować Coral Edge TPU w ImageClassifier w następujący sposób:

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

Krok 3. Zainstaluj pakiet libusb-1.0-0-dev jak poniżej. Jeśli jest już zainstalowany, przejdź do następnego kroku.

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

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

Krok 4. Skompiluj z następującymi konfiguracjami w poleceniu 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.

Wypróbuj narzędzie demonstracyjne CLI biblioteki zadań na urządzeniach Coral Edge TPU. Dowiedz się więcej o wstępnie wytrenowanych modelach Edge TPU i zaawansowanych ustawieniach Edge TPU .

Przykładowe użycie delegata Core ML w C++

Kompletny przykład można znaleźć w teście delegata Core ML klasyfikatora obrazu .

Krok 1. Zależnie od wtyczki delegowania Core ML w docelowym miejscu kompilacji Bazel, na przykład:

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

Krok 2. Skonfiguruj delegata Core ML w opcjach zadania. Na przykład możesz skonfigurować delegata Core ML w ImageClassifier w następujący sposób:

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