TensorFlow Lite-Aufgabenbibliothek

Die TensorFlow Lite-Aufgabenbibliothek enthält eine Reihe leistungsstarker und benutzerfreundlicher aufgabenspezifische Bibliotheken für App-Entwickler zum Erstellen von ML-Umgebungen mit TFLite. Sie bietet optimierte, einsatzfertige Modellschnittstellen für gängiges maschinelles Lernen. wie Bildklassifizierung, Frage und Antwort usw. Oberflächen wurden speziell für jede Aufgabe entwickelt, um und Nutzerfreundlichkeit zu verbessern. Die Aufgabenbibliothek funktioniert plattformübergreifend und wird unterstützt auf Java, C++ und Swift.

Was Sie von der Aufgabenbibliothek erwarten können

  • Saubere und klar definierte APIs, die auch von Nicht-ML-Experten genutzt werden können
    Die Inferenz kann mit nur fünf Codezeilen erfolgen. Nutzen Sie die leistungsstarken und benutzerfreundlichen APIs in der Aufgabenbibliothek als Bausteine ML mit TFLite auf Mobilgeräten entwickeln können.

  • Komplexe, aber gängige Datenverarbeitung
    Unterstützt gängige Logik für visuelles Sehen und Natural Language Processing für die Konvertierung zwischen Ihren Daten und dem für das Modell erforderlichen Datenformat. Liefert die Verarbeitungslogik für Training und Inferenz.

  • Hohe Leistungssteigerung
    Die Datenverarbeitung würde nicht länger als einige Millisekunden dauern. und schnelle Inferenz mit TensorFlow Lite.

  • Erweiterbarkeit und Anpassung
    Sie können alle Vorteile der Task Library-Infrastruktur ganz einfach eigene Android/iOS-Inferenz-APIs erstellen.

Unterstützte Aufgaben

Nachfolgend finden Sie die Liste der unterstützten Aufgabentypen. Die Liste wird voraussichtlich Wir unterstützen immer mehr Anwendungsfälle.

Taskbibliothek mit Bevollmächtigten ausführen

Bevollmächtigte ermöglichen die Hardwarebeschleunigung von TensorFlow Lite-Modellen durch Nutzung von On-Device-Beschleunigern wie dem GPU und Coral Edge TPU Nutzung bei neuronalen Netzwerkvorgängen bietet große Vorteile in Bezug auf die Latenz und Energieeffizienz. Zum Beispiel können GPUs eine bis zu 5-mal beschleunigen und die Inferenz von Coral Edge-TPUs um das 10-Fache, schneller als Desktop-CPUs.

Die Aufgabenbibliothek bietet einfache Konfigurations- und Fallback-Optionen, die Sie einrichten können und Bevollmächtigte verwenden. Die folgenden Beschleuniger werden jetzt in der Task API unterstützt:

  • Android-Geräte <ph type="x-smartling-placeholder">
      </ph>
    • GPU: Java / C++
  • Linux / Mac <ph type="x-smartling-placeholder">
  • iOS <ph type="x-smartling-placeholder">

Die Beschleunigungsunterstützung in Task Swift / Web API ist demnächst verfügbar.

Beispiel für die Verwendung von GPU unter Android in Java

Schritt 1: Fügen Sie die GPU Delegate-Plug-in-Bibliothek dem build.gradle Ihres Moduls hinzu. Datei:

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

Schritt 2: Konfigurieren Sie den GPU-Delegaten in den Aufgabenoptionen über BaseOptions festgelegt werden. Sie können die GPU beispielsweise in ObjectDetector so einrichten:

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

Beispielnutzung einer GPU unter Android in C++

Schritt 1: abhängig vom GPU Delegate-Plug-in in Ihrem Bali-Build-Ziel, z. B.:

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

Schritt 2: Konfigurieren Sie den GPU-Delegaten in den Aufgabenoptionen. Sie können beispielsweise GPU in BertQuestionAnswerer:

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

Erweiterte Beschleunigereinstellungen hier.

Beispiel für die Verwendung der Coral Edge TPU in Python

Konfigurieren Sie Coral Edge TPU in den Basisoptionen der Aufgabe. So können Sie zum Beispiel Richten Sie Coral Edge TPU so in ImageClassifier ein:

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

Beispiel für die Verwendung einer Coral Edge TPU in C++

Schritt 1: Orientieren Sie sich am Coral Edge TPU Delegat-Plug-in in Ihrem Looker-Build-Ziel an, Beispiele:

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

Schritt 2: Konfigurieren Sie Coral Edge TPU in den Aufgabenoptionen. Sie können beispielsweise So richten Sie Coral Edge TPU in ImageClassifier ein:

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

Schritt 3: Installieren Sie das libusb-1.0-0-dev-Paket wie unten beschrieben. Wenn es bereits können Sie mit dem nächsten Schritt fortfahren.

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

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

Schritt 4: Kompilieren Sie mit den folgenden Konfigurationen in Ihrem Bali-Befehl:

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

Demo der Task Library-Befehlszeile testen Tool mit Ihren Coral Edge TPU-Geräten. Mehr über die vortrainierte Edge TPU erfahren Modelle und erweiterte Edge TPU Einstellungen.

Beispielverwendung von Core ML Delegate in C++

Ein vollständiges Beispiel finden Sie unter Image Classifier Core ML Delegate Testen.

Schritt 1: Sie hängen vom Core ML Delegate-Plug-in in Ihrem Looker-Build-Ziel ab, z. B. als:

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

Schritt 2: Konfigurieren Sie Core ML Delegate in den Aufgabenoptionen. Sie können beispielsweise Core ML Delegate in ImageClassifier so einrichten:

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