Biblioteka e detyrave TensorFlow Lite

TensorFlow Lite Task Library përmban një grup bibliotekash të fuqishme dhe të lehta për t'u përdorur për detyra specifike për zhvilluesit e aplikacioneve për të krijuar përvoja ML me TFLite. Ai siguron ndërfaqe të optimizuara të modelit jashtë kutisë për detyrat e njohura të mësimit të makinerive, të tilla si klasifikimi i imazheve, pyetjet dhe përgjigjet, etj. Ndërfaqet e modelit janë krijuar posaçërisht për secilën detyrë për të arritur performancën dhe përdorshmërinë më të mirë. Task Library funksionon ndër-platformë dhe mbështetet në Java, C++ dhe Swift.

Çfarë të presësh nga Task Library

  • API të pastra dhe të mirëpërcaktuara të përdorshme nga jo-ekspertë të ML
    Konkluzioni mund të bëhet brenda vetëm 5 rreshtave të kodit. Përdorni API-të e fuqishme dhe të lehta për t'u përdorur në bibliotekën e detyrave si blloqe ndërtimi për t'ju ndihmuar të zhvilloni lehtësisht ML me TFLite në pajisjet celulare.

  • Përpunimi kompleks, por i zakonshëm i të dhënave
    Mbështet vizionin e përbashkët dhe logjikën e përpunimit të gjuhës natyrore për të konvertuar midis të dhënave tuaja dhe formatit të të dhënave të kërkuar nga modeli. Ofron të njëjtën logjikë përpunimi të ndashëm për trajnim dhe konkluzion.

  • Fitimi i performancës së lartë
    Përpunimi i të dhënave nuk do të zgjaste më shumë se disa milisekonda, duke siguruar përvojën e shpejtë të përfundimit duke përdorur TensorFlow Lite.

  • Zgjerimi dhe personalizimi
    Ju mund të shfrytëzoni të gjitha përfitimet që ofron infrastruktura e Task Library dhe të ndërtoni lehtësisht API-të tuaja të konkluzionit Android/iOS.

Detyrat e mbështetura

Më poshtë është lista e llojeve të detyrave të mbështetura. Lista pritet të rritet ndërsa ne vazhdojmë të mundësojmë gjithnjë e më shumë raste përdorimi.

Ekzekutoni Bibliotekën e Detyrave me Delegatë

Delegatët mundësojnë përshpejtimin e harduerit të modeleve TensorFlow Lite duke përdorur përshpejtuesit në pajisje si GPU dhe Coral Edge TPU . Përdorimi i tyre për operacionet e rrjetit nervor ofron përfitime të mëdha për sa i përket vonesës dhe efikasitetit të energjisë. Për shembull, GPU-të mund të ofrojnë deri në 5 herë shpejtësi të vonesës në pajisjet celulare dhe TPU-të Coral Edge mund të nxjerrin përfundime 10 herë më shpejt se CPU-të e desktopit.

Biblioteka e detyrave ofron konfigurim të lehtë dhe opsione të reja për ju që të konfiguroni dhe përdorni delegatët. Përshpejtuesit e mëposhtëm tani mbështeten në Task API:

Mbështetja e përshpejtimit në Task Swift / Web API do të vijë së shpejti.

Shembull i përdorimit të GPU në Android në Java

Hapi 1. Shtoni bibliotekën e shtojcave të delegatëve të GPU-së në skedarin build.gradle të modulit tuaj:

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

Hapi 2. Konfiguro delegatin e GPU-së në opsionet e detyrave përmes BaseOptions . Për shembull, mund të konfiguroni GPU në ObjectDetector si më poshtë:

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

Shembull i përdorimit të GPU në Android në C++

Hapi 1. Varuni nga shtojca e deleguar GPU në objektivin tuaj të ndërtimit të bazel, si p.sh.

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

Hapi 2. Konfiguro delegatin e GPU-së në opsionet e detyrave. Për shembull, mund të konfiguroni GPU në BertQuestionAnswerer si më poshtë:

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

Eksploroni cilësimet më të avancuara të përshpejtuesit këtu .

Shembull i përdorimit të Coral Edge TPU në Python

Konfiguro Coral Edge TPU në opsionet bazë të detyrës. Për shembull, mund të konfiguroni Coral Edge TPU në ImageClassifier si më poshtë:

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

Shembull i përdorimit të Coral Edge TPU në C++

Hapi 1. Varuni nga shtojca e deleguar e Coral Edge TPU në objektivin tuaj të ndërtimit të bazelit, si p.sh.

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

Hapi 2. Konfiguro Coral Edge TPU në opsionet e detyrave. Për shembull, mund të konfiguroni Coral Edge TPU në ImageClassifier si më poshtë:

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

Hapi 3. Instaloni paketën libusb-1.0-0-dev si më poshtë. Nëse është instaluar tashmë, kaloni në hapin tjetër.

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

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

Hapi 4. Përpiloni me konfigurimet e mëposhtme në komandën tuaj 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.

Provoni mjetin demonstrues të Task Library CLI me pajisjet tuaja TPU Coral Edge. Eksploroni më shumë mbi modelet e para-trajnuara TPU të Edge dhe cilësimet e avancuara të Edge TPU .

Shembull i përdorimit të Delegatit Core ML në C++

Një shembull i plotë mund të gjendet në Testin e Delegatit të Klasifikimit të Imazhit Core ML .

Hapi 1. Varuni nga shtojca e delegatit Core ML në objektivin tuaj të ndërtimit të bazel, si p.sh. 

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

Hapi 2. Konfiguro Core ML Delegate në opsionet e detyrave. Për shembull, mund të konfiguroni Delegatin Core ML në ImageClassifier si më poshtë: 

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