Biblioteka zadań TensorFlow Lite

Biblioteka zadań TensorFlow Lite zawiera zestaw zaawansowanych i łatwych w użyciu biblioteki do konkretnych zadań, które pozwalają deweloperom aplikacji tworzyć środowiska ML za pomocą TFLite. Udostępnia zoptymalizowane gotowe do użycia interfejsy modelu dla popularnych systemów uczących się takich jak klasyfikacja obrazów, pytanie i odpowiedź itp. Model modelu interfejsy są zaprojektowane specjalnie pod kątem każdego zadania, aby zapewnić wydajności i łatwości obsługi. Biblioteka zadań działa na wielu platformach i jest obsługiwana Java, C++ i Swift.

Czego możesz się spodziewać w bibliotece zadań

  • Przejrzyste i dobrze zdefiniowane interfejsy API, z których mogą korzystać osoby niebędące ekspertami od systemów uczących się
    Takie wnioskowanie można przeprowadzać z wykorzystaniem 5 wierszy kodu. Korzystaj z zaawansowanych funkcji łatwe w użyciu interfejsy API w bibliotece zadań jako elementy składowe ułatwiające pracę tworzyć systemy uczące się przy użyciu TFLite'a na urządzeniach mobilnych.

  • Złożone, ale powszechne przetwarzanie danych
    Obsługuje wspólną logikę przetwarzania języka naturalnego i wizję na potrzeby konwersji między danymi a formatem danych wymaganym przez model. Zapewnia tę samą, współdzieloną logikę przetwarzania do trenowania i wnioskowania.

  • Wysoki wzrost wydajności
    Przetwarzanie danych nie potrwa dłużej niż kilka milisekund, dzięki czemu do szybkiego wnioskowania za pomocą TensorFlow Lite.

  • Możliwość rozszerzania i dostosowywania
    Możesz korzystać ze wszystkich zalet, jakie zapewnia infrastruktura biblioteki zadań łatwo tworzyć własne interfejsy API wnioskowania na Androida/iOS.

Obsługiwane zadania

Poniżej znajdziesz listę obsługiwanych typów zadań. Lista będzie się powiększać w miarę upływu czasu włączamy także coraz więcej przypadków użycia.

Uruchamianie biblioteki zadań z przedstawicielami

Przedstawiciele włączają akcelerację sprzętową Modele TensorFlow Lite z wykorzystaniem akceleratorów na urządzeniu, takich jak GPU i Coral Edge TPU. Wykorzystanie w operacjach sieci neuronowych, co ma ogromne korzyści, jeśli chodzi o opóźnienia. i wydajność energii. Na przykład GPU może zapewnić do 5x przyspieszenie opóźnienia na urządzeniach mobilnych, a przez układy Coral Edge TPU 10-krotnie częściej szybsze niż komputery stacjonarne.

Biblioteka zadań zapewnia łatwą konfigurację i opcje zastępcze i korzystanie z przedstawicieli. Interfejs Task API obsługuje teraz te akceleratory:

Obsługa akceleracji w Task Swift / Web API będzie dostępna wkrótce.

Przykład użycia GPU na Androidzie w Javie

Krok 1. Dodaj bibliotekę wtyczki do delegowania GPU do pola build.gradle modułu plik:

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 przekazywanie dostępu do GPU w opcjach zadania przez BaseOptions. Możesz na przykład skonfigurować GPU w ObjectDetector w ten 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ład użycia GPU na Androidzie w języku C++

Krok 1. Skorzystaj z wtyczki delegowanej GPU w celu kompilacji bazel, na przykład:

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

Krok 2. Skonfiguruj przekazywanie dostępu do GPU w opcjach zadania. Możesz na przykład 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);

Poznaj bardziej zaawansowane ustawienia akceleratora tutaj.

Przykład użycia Coral Edge TPU w Pythonie

Skonfiguruj Coral Edge TPU w opcjach podstawowych zadania. Możesz na przykład: skonfiguruj Coral Edge TPU w ImageClassifier w ten 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ład użycia Coral Edge TPU w C++

Krok 1. Skorzystaj z wtyczki Coral Edge TPU do przekazywania dostępu w celu 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. Możesz na przykład ustawić Coral Edge TPU w ImageClassifier w ten 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ż włączona , 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. Wykonaj te czynności 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 wersję demonstracyjną interfejsu wiersza poleceń biblioteki zadań na urządzeniach Coral Edge TPU. Dowiedz się więcej o wstępnie wytrenowanej technologii Edge TPU modele i zaawansowane Edge TPU ustawieniach.

Przykład użycia przedstawiciela Core ML w C++

Pełny przykład można znaleźć tutaj: Image Classifier Core ML Delegate Testuj.

Krok 1. Zależnie od wtyczki Core ML w celu kompilacji bazel, taka jak jako:

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

Krok 2. Skonfiguruj przedstawiciela Core ML w opcjach zadania. Możesz na przykład ustawić Upoważnienie 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();