TensorFlow लाइट टास्क लाइब्रेरी

TensorFlow लाइट टास्क लाइब्रेरी में TFLite के साथ ML अनुभव बनाने के लिए ऐप डेवलपर्स के लिए शक्तिशाली और उपयोग में आसान कार्य-विशिष्ट लाइब्रेरी का एक सेट है। यह लोकप्रिय मशीन लर्निंग कार्यों, जैसे छवि वर्गीकरण, प्रश्न और उत्तर, आदि के लिए अनुकूलित आउट-ऑफ-बॉक्स मॉडल इंटरफेस प्रदान करता है। मॉडल इंटरफेस विशेष रूप से प्रत्येक कार्य के लिए सर्वश्रेष्ठ प्रदर्शन और उपयोगिता प्राप्त करने के लिए डिज़ाइन किए गए हैं। टास्क लाइब्रेरी क्रॉस-प्लेटफॉर्म पर काम करती है और जावा, सी ++ और स्विफ्ट पर समर्थित है।

टास्क लाइब्रेरी से क्या उम्मीद करें

  • गैर-एमएल-विशेषज्ञों द्वारा प्रयोग करने योग्य स्वच्छ और अच्छी तरह से परिभाषित एपीआई
    कोड की केवल 5 पंक्तियों के भीतर अनुमान लगाया जा सकता है। टास्क लाइब्रेरी में शक्तिशाली और उपयोग में आसान एपीआई का उपयोग बिल्डिंग ब्लॉक्स के रूप में करें ताकि आप मोबाइल उपकरणों पर टीएफलाइट के साथ एमएल को आसानी से विकसित कर सकें।

  • जटिल लेकिन सामान्य डेटा प्रोसेसिंग
    आपके डेटा और मॉडल द्वारा आवश्यक डेटा प्रारूप के बीच कनवर्ट करने के लिए सामान्य दृष्टि और प्राकृतिक भाषा प्रसंस्करण तर्क का समर्थन करता है। प्रशिक्षण और अनुमान के लिए समान, साझा करने योग्य प्रसंस्करण तर्क प्रदान करता है।

  • उच्च प्रदर्शन लाभ
    डेटा प्रोसेसिंग में कुछ मिलीसेकंड से अधिक समय नहीं लगेगा, जिससे TensorFlow Lite का उपयोग करके तेज़ अनुमान अनुभव सुनिश्चित हो सके।

  • विस्तारशीलता और अनुकूलन
    आप टास्क लाइब्रेरी इन्फ्रास्ट्रक्चर द्वारा प्रदान किए जाने वाले सभी लाभों का लाभ उठा सकते हैं और आसानी से अपना खुद का एंड्रॉइड/आईओएस अनुमान एपीआई बना सकते हैं।

समर्थित कार्य

नीचे समर्थित कार्य प्रकारों की सूची दी गई है। सूची के बढ़ने की उम्मीद है क्योंकि हम अधिक से अधिक उपयोग के मामलों को सक्षम करना जारी रखते हैं।

प्रतिनिधियों के साथ कार्य पुस्तकालय चलाएँ

प्रतिनिधि GPU और Coral Edge TPU जैसे ऑन-डिवाइस त्वरक का लाभ उठाकर TensorFlow Lite मॉडल के हार्डवेयर त्वरण को सक्षम करते हैं। तंत्रिका नेटवर्क संचालन के लिए उनका उपयोग करने से विलंबता और शक्ति दक्षता के मामले में भारी लाभ मिलता है। उदाहरण के लिए, GPU मोबाइल उपकरणों पर विलंबता में 5x तक की गति प्रदान कर सकते हैं, और Coral Edge TPU, डेस्कटॉप CPU की तुलना में 10x तेज गति प्रदान करते हैं।

टास्क लाइब्रेरी आपको प्रतिनिधियों को स्थापित करने और उपयोग करने के लिए आसान कॉन्फ़िगरेशन और फ़ॉल बैक विकल्प प्रदान करती है। निम्नलिखित त्वरक अब कार्य API में समर्थित हैं:

टास्क स्विफ्ट / वेब एपीआई में एक्सेलेरेशन सपोर्ट जल्द ही आ रहा है।

जावा में Android पर GPU का उदाहरण उपयोग

चरण 1. अपने मॉड्यूल की build.gradle फ़ाइल में GPU प्रतिनिधि प्लगइन लाइब्रेरी जोड़ें:

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

चरण 2। बेसऑप्शन के माध्यम से कार्य विकल्पों में GPU प्रतिनिधि को कॉन्फ़िगर करें। उदाहरण के लिए, आप ObjectDetecor में GPU को निम्नानुसार सेट कर सकते हैं:

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

C++ में Android पर GPU का उदाहरण उपयोग

चरण 1. अपने bazel निर्माण लक्ष्य में GPU प्रतिनिधि प्लगइन पर निर्भर करें, जैसे:

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

अन्य प्रतिनिधि विकल्पों में शामिल हैं:

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

चरण 2. कार्य विकल्पों में GPU प्रतिनिधि को कॉन्फ़िगर करें। उदाहरण के लिए, आप BertQuestionAnswerer में GPU को निम्नानुसार सेट कर सकते हैं:

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

यहां अधिक उन्नत त्वरक सेटिंग्स का अन्वेषण करें

पायथन में कोरल एज टीपीयू का उदाहरण उपयोग

कार्य के आधार विकल्पों में कोरल एज टीपीयू को कॉन्फ़िगर करें। उदाहरण के लिए, आप ImageClassifier में Coral Edge TPU को निम्नानुसार सेट कर सकते हैं:

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

सी++ में कोरल एज टीपीयू का उदाहरण उपयोग

चरण 1. अपने बेज़ल बिल्ड लक्ष्य में कोरल एज टीपीयू डेलिगेट प्लगइन पर निर्भर करें, जैसे:

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

चरण 2. कार्य विकल्पों में कोरल एज टीपीयू को कॉन्फ़िगर करें। उदाहरण के लिए, आप ImageClassifier में Coral Edge TPU को निम्नानुसार सेट कर सकते हैं:

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

चरण 3. नीचे के रूप में libusb-1.0-0-dev पैकेज स्थापित करें। यदि यह पहले से स्थापित है, तो अगले चरण पर जाएं।

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

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

चरण 4. अपने 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.

अपने कोरल एज टीपीयू उपकरणों के साथ टास्क लाइब्रेरी सीएलआई डेमो टूल आज़माएं। पहले से प्रशिक्षित एज टीपीयू मॉडल और उन्नत एज टीपीयू सेटिंग्स के बारे में अधिक जानें।

सी++ में कोर एमएल प्रतिनिधि का उदाहरण उपयोग

एक पूरा उदाहरण इमेज क्लासिफायर कोर एमएल डेलिगेट टेस्ट में पाया जा सकता है।

चरण 1. अपने बेज़ल बिल्ड लक्ष्य में कोर एमएल प्रतिनिधि प्लगइन पर निर्भर करें, जैसे:

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

चरण 2. कार्य विकल्पों में कोर एमएल प्रतिनिधि को कॉन्फ़िगर करें। उदाहरण के लिए, आप ImageClassifier में Core ML प्रतिनिधि को निम्नानुसार सेट कर सकते हैं:

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