Eine Frage haben? Verbinden Sie sich mit der Community im TensorFlow Forum Visit Forum

TensorFlow Lite-Aufgabenbibliothek

Die TensorFlow Lite-Aufgabenbibliothek enthält eine Reihe leistungsstarker und benutzerfreundlicher aufgabenspezifischer Bibliotheken, mit denen App-Entwickler ML-Erfahrungen mit TFLite erstellen können. Es bietet optimierte sofort einsatzbereite Modellschnittstellen für gängige maschinelle Lernaufgaben wie Bildklassifizierung, Frage und Antwort usw. Die Modellschnittstellen wurden speziell für jede Aufgabe entwickelt, um die beste Leistung und Benutzerfreundlichkeit zu erzielen. Die Task Library funktioniert plattformübergreifend und wird unter Java, C ++ und Swift unterstützt.

Was Sie von der Aufgabenbibliothek erwarten können

  • Saubere und klar definierte APIs, die von Nicht-ML-Experten verwendet werden können
    Inferenz kann innerhalb von nur 5 Codezeilen erfolgen. Verwenden Sie die leistungsstarken und benutzerfreundlichen APIs in der Aufgabenbibliothek als Bausteine, um ML mit TFLite auf Mobilgeräten einfach zu entwickeln.

  • Komplexe, aber gemeinsame Datenverarbeitung
    Unterstützt die allgemeine Vision und die Verarbeitungslogik in natürlicher Sprache, um zwischen Ihren Daten und dem vom Modell geforderten Datenformat zu konvertieren. Bietet dieselbe gemeinsam nutzbare Verarbeitungslogik für Training und Inferenz.

  • Hoher Leistungsgewinn
    Die Datenverarbeitung würde nicht länger als ein paar Millisekunden dauern, um eine schnelle Inferenz mit TensorFlow Lite zu gewährleisten.

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

Unterstützte Aufgaben

Unten finden Sie eine Liste der unterstützten Aufgabentypen. Die Liste wird voraussichtlich wachsen, da wir immer mehr Anwendungsfälle ermöglichen.

Führen Sie die Aufgabenbibliothek mit Delegaten aus

Delegierte ermöglichen die Hardwarebeschleunigung von TensorFlow Lite-Modellen, indem sie Gerätebeschleuniger wie die GPU und die Coral Edge-TPU nutzen . Die Verwendung für den Betrieb neuronaler Netze bietet enorme Vorteile in Bezug auf Latenz und Energieeffizienz. Beispielsweise können GPUs die Latenz auf Mobilgeräten um das 5-fache beschleunigen , und Coral Edge-TPUs schließen 10- mal schneller als Desktop-CPUs.

Die Aufgabenbibliothek bietet einfache Konfigurations- und Fallback-Optionen zum Einrichten und Verwenden von Delegaten. Die folgenden Beschleuniger werden jetzt in der Task C ++ - API unterstützt:

Core ML-Delegat für iOS und Beschleunigungsunterstützung in Task Java / Swift / Web API sind in Kürze verfügbar.

Beispiel für die Verwendung einer GPU unter Android

Schritt 1. Hängen Sie vom GPU-Delegaten-Plugin in Ihrem Bazel-Build-Ziel ab, z.

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

Weitere Optionen für Delegierte sind:

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

Schritt 2. Konfigurieren Sie den GPU-Delegaten in den Aufgabenoptionen. Beispielsweise können Sie die GPU in BertQuestionAnswerer wie folgt 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);

Weitere Informationen zu den Beschleunigereinstellungen finden Sie hier .

Beispiel für die Verwendung von Coral Edge TPU

Schritt 1. Abhängig vom Coral Edge TPU-Delegaten-Plugin in Ihrem Bazel-Build-Ziel, z. B.:

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

Schritt 2. Konfigurieren Sie Coral Edge TPU in den Aufgabenoptionen. Beispielsweise können Sie Coral Edge TPU in ImageClassifier wie folgt ImageClassifier :

// 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 libusb-1.0-0-dev . Wenn es bereits installiert ist, fahren Sie mit dem nächsten Schritt fort.

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

Probieren Sie das CLI-Demo-Tool der Task Library mit Ihren Coral Edge TPU-Geräten aus. Erfahren Sie mehr über die vorgefertigten Edge-TPU-Modelle und die erweiterten Edge-TPU-Einstellungen .