Dziękujemy za zapoznanie się z Google I/O. Zobacz wszystkie sesje na żądanie Oglądaj na żądanie

Biblioteka zadań TensorFlow Lite

Biblioteka zadań TensorFlow Lite zawiera zestaw potężnych i łatwych w użyciu bibliotek specyficznych dla zadań dla twórców aplikacji do tworzenia środowisk uczenia maszynowego za pomocą TFLite. Zapewnia zoptymalizowane gotowe 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 oczekiwać od biblioteki zadań

  • Czyste i dobrze zdefiniowane interfejsy API, z których mogą korzystać osoby niebędące ekspertami od uczenia maszynowego
    Wnioskowanie można przeprowadzić w ciągu zaledwie 5 linii kodu. Korzystaj z potężnych i łatwych w użyciu interfejsów API w bibliotece zadań jako bloków konstrukcyjnych ułatwiających tworzenie uczenia maszynowego za pomocą TFLite na urządzeniach mobilnych.

  • Złożone, ale powszechne przetwarzanie danych
    Obsługuje wspólną logikę przetwarzania wizji i 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 dostosowanie
    Możesz wykorzystać wszystkie zalety infrastruktury biblioteki zadań i łatwo tworzyć 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.

Uruchom bibliotekę zadań z delegatami

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

Biblioteka zadań zapewnia łatwą konfigurację i opcje awaryjne umożliwiające konfigurowanie i używanie pełnomocników. Następujące akceleratory są teraz obsługiwane w interfejsie API zadań:

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

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 pełnomocnika GPU w opcjach zadania poprzez BaseOptions . Na przykład możesz skonfigurować GPU 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. Polegaj na wtyczce delegata GPU w celu kompilacji Bazel, takiej jak:

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

Inne opcje delegatów obejmują:

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

Krok 2. Skonfiguruj pełnomocnika 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. Polegaj na wtyczce delegata Coral Edge TPU w celu kompilacji Bazel, 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 CLI biblioteki zadań z urządzeniami Coral Edge TPU. Dowiedz się więcej o wytrenowanych modelach Edge TPU i zaawansowanych ustawieniach Edge TPU .

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

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

Krok 1. Polegaj na wtyczce delegata Core ML w celu kompilacji Bazel, takiej jak:

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

Krok 2. Skonfiguruj Core ML Delegat 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();