इमेज एम्बेडर इंटिग्रेट करें

इमेज एम्बेडर, इमेज को हाई-डाइमेंशनल फ़ीचर वेक्टर में एम्बेड करने की सुविधा देते हैं. यह वेक्टर, इमेज के सिमैंटिक मतलब को दिखाता है. इसके बाद, इसकी तुलना अन्य इमेज के फ़ीचर वेक्टर से की जा सकती है, ताकि यह पता लगाया जा सके कि वे सिमैंटिक तौर पर कितनी मिलती-जुलती हैं.

इमेज सर्च के उलट, इमेज एम्बेडर की मदद से, इमेज के कॉर्पस से बनाए गए पहले से तय इंडेक्स में खोजने के बजाय, तुरंत इमेज के बीच समानता का पता लगाया जा सकता है.

अपने मोबाइल ऐप्लिकेशन में कस्टम इमेज एम्बेडर को डिप्लॉय करने के लिए, Task Library ImageEmbedder API का इस्तेमाल करें.

ImageEmbedder API की मुख्य सुविधाएं

• इनपुट इमेज को प्रोसेस करना. इसमें इमेज को घुमाना, उसका साइज़ बदलना, और कलर स्पेस बदलना शामिल है.

• इनपुट इमेज में दिलचस्पी वाला क्षेत्र.

• यह एक बिल्ट-इन यूटिलिटी फ़ंक्शन है. इसका इस्तेमाल, फ़ीचर वेक्टर के बीच कोसाइन सिमिलैरिटी का हिसाब लगाने के लिए किया जाता है.

इमेज एम्बेड करने की सुविधा देने वाले मॉडल

इन मॉडल में ImageEmbedder API का इस्तेमाल किया जा सकता है.

• Kaggle Models पर Google इमेज मॉड्यूल के कलेक्शन से फ़ीचर वेक्टर मॉडल.

• कस्टम मॉडल, जो मॉडल के साथ काम करने की ज़रूरी शर्तों को पूरा करते हों.

C++ में अनुमान चलाने की सुविधा

// Initialization
ImageEmbedderOptions options:
options.mutable_model_file_with_metadata()->set_file_name(model_path);
options.set_l2_normalize(true);
std::unique_ptr<ImageEmbedder> image_embedder = ImageEmbedder::CreateFromOptions(options).value();

// Create input frame_buffer_1 and frame_buffer_2 from your inputs `image_data1`, `image_data2`, `image_dimension1` and `image_dimension2`.
// See more information here: tensorflow_lite_support/cc/task/vision/utils/frame_buffer_common_utils.h
std::unique_ptr<FrameBuffer> frame_buffer_1 = CreateFromRgbRawBuffer(
      image_data1, image_dimension1);
std::unique_ptr<FrameBuffer> frame_buffer_2 = CreateFromRgbRawBuffer(
      image_data2, image_dimension2);

// Run inference on two images.
const EmbeddingResult result_1 = image_embedder->Embed(*frame_buffer_1);
const EmbeddingResult result_2 = image_embedder->Embed(*frame_buffer_2);

// Compute cosine similarity.
double similarity = ImageEmbedder::CosineSimilarity(
    result_1.embeddings[0].feature_vector(),
    result_2.embeddings[0].feature_vector());

ImageEmbedder को कॉन्फ़िगर करने के ज़्यादा विकल्पों के लिए, सोर्स कोड देखें.

Python में अनुमान लगाने की सुविधा का इस्तेमाल करना

पहला चरण: TensorFlow Lite Support Pypi पैकेज इंस्टॉल करें.

TensorFlow Lite Support Pypi पैकेज को इंस्टॉल करने के लिए, इस निर्देश का इस्तेमाल करें:

pip install tflite-support

दूसरा चरण: मॉडल का इस्तेमाल करना

from tflite_support.task import vision

# Initialization.
image_embedder = vision.ImageEmbedder.create_from_file(model_path)

# Run inference on two images.
image_1 = vision.TensorImage.create_from_file('/path/to/image1.jpg')
result_1 = image_embedder.embed(image_1)
image_2 = vision.TensorImage.create_from_file('/path/to/image2.jpg')
result_2 = image_embedder.embed(image_2)

# Compute cosine similarity.
feature_vector_1 = result_1.embeddings[0].feature_vector
feature_vector_2 = result_2.embeddings[0].feature_vector
similarity = image_embedder.cosine_similarity(
    result_1.embeddings[0].feature_vector, result_2.embeddings[0].feature_vector)

ImageEmbedder को कॉन्फ़िगर करने के ज़्यादा विकल्पों के लिए, सोर्स कोड देखें.

परिणामों के उदाहरण

सामान्य किए गए फ़ीचर वेक्टर के बीच कोसाइन समानता, -1 और 1 के बीच का स्कोर दिखाती है. कोसाइन सिमिलैरिटी जितनी ज़्यादा हो उतना बेहतर है. इसका मतलब है कि अगर कोसाइन सिमिलैरिटी 1 है, तो दोनों वेक्टर एक जैसे हैं.

Cosine similarity: 0.954312

अपने मॉडल और टेस्ट डेटा के साथ, ImageEmbedder के लिए, इस्तेमाल में आसान सीएलआई डेमो टूल आज़माएं.

मॉडल के साथ काम करने से जुड़ी ज़रूरी शर्तें

ImageEmbedder एपीआई को TFLite मॉडल की ज़रूरत होती है. इसमें TFLite मॉडल मेटाडेटा शामिल करना ज़रूरी नहीं है, लेकिन इसे शामिल करने का सुझाव दिया जाता है.

इमेज एम्बेड करने की सुविधा के साथ काम करने वाले मॉडल को ये ज़रूरी शर्तें पूरी करनी होंगी:

• इनपुट इमेज टेंसर (kTfLiteUInt8/kTfLiteFloat32)

  • [batch x height x width x channels] साइज़ की इमेज का इनपुट.
  • बैच इन्फ़रेंस की सुविधा काम नहीं करती (batch की वैल्यू 1 होनी चाहिए).
  • सिर्फ़ आरजीबी इनपुट इस्तेमाल किए जा सकते हैं (channels की वैल्यू 3 होनी चाहिए).
  • अगर टाइप kTfLiteFloat32 है, तो इनपुट को सामान्य बनाने के लिए, मेटाडेटा में NormalizationOptions अटैच करना ज़रूरी है.

• कम से कम एक आउटपुट टेंसर (kTfLiteUInt8/kTfLiteFloat32)

  • इस आउटपुट लेयर के लिए, लौटाए गए फ़ीचर वेक्टर के N डाइमेंशन के हिसाब से N कॉम्पोनेंट होते हैं.
  • दो या चार डाइमेंशन, यानी कि [1 x N] या [1 x 1 x 1 x N].