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

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

टास्क लाइब्रेरी से क्या अपेक्षा करें

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

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

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

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

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

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

• विजन एपीआई

  • इमेजक्लासिफायर
  • ऑब्जेक्ट डिटेक्टर
  • इमेजसेगमेंटर
  • छवि खोजकर्ता
  • इमेज एंबेडर

• प्राकृतिक भाषा (एनएल) एपीआई

  • एनएलवर्गीकारक
  • BertNLClassifier
  • बर्ट प्रश्न उत्तर देने वाला
  • पाठ खोजकर्ता
  • टेक्स्ट एंबेडर

• ऑडियो एपीआई

  • ऑडियोक्लासिफायर

• कस्टम एपीआई

  • टास्क एपीआई बुनियादी ढांचे का विस्तार करें और अनुकूलित एपीआई का निर्माण करें।

डेलीगेट्स के साथ टास्क लाइब्रेरी चलाएं

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

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

• एंड्रॉयड
  • जीपीयू : जावा / सी ++
  • एनएनएपीआई : जावा / सी ++
  • षट्कोण : सी ++
• लिनक्स / मैक
  • कोरल एज टीपीयू : सी++
• आईओएस
  • कोर एमएल प्रतिनिधि : सी ++

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

जावा में एंड्रॉइड पर जीपीयू का उदाहरण उपयोग

चरण 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. बेसऑप्शन के माध्यम से कार्य विकल्पों में जीपीयू प्रतिनिधि को कॉन्फ़िगर करें। उदाहरण के लिए, आप निम्नानुसार ObjectDetector में 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 में कोरल एज 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)

C++ में कोरल एज TPU का उदाहरण उपयोग

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

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

चरण 2. कार्य विकल्पों में कोरल एज टीपीयू को कॉन्फ़िगर करें। उदाहरण के लिए, आप ImageClassifier में कोरल एज 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. अपने bazel बिल्ड लक्ष्य में Core ML डेलिगेट प्लगइन पर निर्भर करें, जैसे:

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

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

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