Biblioteka zadań TensorFlow Lite

Biblioteka zadań TensorFlow Lite zawiera zestaw potężnych i łatwych w użyciu bibliotek specyficznych dla zadań dla programistów aplikacji do tworzenia środowisk ML za pomocą TFLite. Zapewnia zoptymalizowane, gotowe do użycia interfejsy modeli dla 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 oczekiwać od Biblioteki zadań

  • Czyste i dobrze zdefiniowane interfejsy API, z których mogą korzystać osoby niebędące ekspertami w dziedzinie uczenia maszynowego
    Wnioskowanie można wykonać w zaledwie 5 wierszach kodu. Użyj zaawansowanych i łatwych w użyciu interfejsów API w bibliotece zadań jako bloków konstrukcyjnych, które pomogą Ci łatwo tworzyć ML 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 między danymi a formatem danych wymaganym przez model. Zapewnia tę samą, współużytkowaną logikę przetwarzania na potrzeby uczenia i wnioskowania.

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

  • Rozszerzalność i personalizacja
    Możesz wykorzystać wszystkie korzyści, jakie zapewnia infrastruktura 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ć, ponieważ nadal udostępniamy coraz więcej przypadków użycia.

Uruchom bibliotekę zadań z delegatami

Delegaci umożliwiają sprzętową akcelerację modeli TensorFlow Lite, wykorzystując akceleratory na urządzeniu, takie jak GPU i Coral Edge TPU . Wykorzystanie ich do operacji w sieciach neuronowych zapewnia ogromne korzyści w zakresie opóźnień i wydajności energetycznej. Na przykład procesory graficzne mogą zapewnić nawet 5-krotne przyspieszenie w opóźnieniach na urządzeniach mobilnych, a procesory Coral Edge TPU mogą wnioskować 10 razy szybciej niż procesory do komputerów stacjonarnych.

Biblioteka zadań zapewnia łatwą konfigurację i opcje powrotu do konfiguracji i korzystania z delegatów. Następujące akceleratory są teraz obsługiwane w interfejsie API zadań:

Wkrótce pojawi się obsługa akceleracji w Task Swift / Web API.

Przykładowe użycie GPU na Androidzie w Javie

Krok 1. Dodaj bibliotekę wtyczek delegata GPU do pliku build.gradle 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'
}

Krok 2. Skonfiguruj delegata GPU w opcjach zadań za pomocą BaseOptions . Na przykład możesz skonfigurować GPU w ObjectDetecor 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ży od wtyczki delegata GPU w docelowej kompilacji bazela, takiej jak:

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

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ć GPU 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);

Zapoznaj się z bardziej zaawansowanymi ustawieniami akceleratora tutaj .

Przykładowe użycie 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 użycie Coral Edge TPU w C++

Krok 1. Zależy od wtyczki delegata Coral Edge TPU w docelowej kompilacji bazela, takiej jak:

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 swoim 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 biblioteki zadań CLI z urządzeniami Coral Edge TPU. Dowiedz się więcej o przeszkolonych modelach Edge TPU i zaawansowanych ustawieniach Edge TPU .

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

Pełny przykład można znaleźć w Image Classifier Core ML Delegate Test .

Krok 1. Zależy od wtyczki delegata Core ML w docelowej kompilacji bazel, takiej jak:

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

Krok 2. Skonfiguruj Core ML Delegate w opcjach zadania. Na przykład możesz skonfigurować Core ML Delegate 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();