छवि खोजकर्ताओं को एकीकृत करें

छवि खोज छवियों के डेटाबेस में समान छवियों को खोजने की अनुमति देती है। यह खोज क्वेरी को क्वेरी के अर्थपूर्ण अर्थ का प्रतिनिधित्व करने वाले एक उच्च-आयामी वेक्टर में एम्बेड करके काम करता है, इसके बाद ScaNN (स्केलेबल निकटतम पड़ोसियों) का उपयोग करके पूर्वनिर्धारित, कस्टम इंडेक्स में समानता खोज करता है।

छवि वर्गीकरण के विपरीत, पहचानी जा सकने वाली वस्तुओं की संख्या का विस्तार करने के लिए पूरे मॉडल को फिर से प्रशिक्षित करने की आवश्यकता नहीं होती है। सूचकांक को फिर से बनाकर नए आइटम जोड़े जा सकते हैं। यह छवियों के बड़े (100k+ आइटम) डेटाबेस के साथ काम करने में भी सक्षम बनाता है।

अपने कस्टम छवि खोजकर्ता को अपने मोबाइल ऐप्स में तैनात करने के लिए टास्क लाइब्रेरी ImageSearcher एपीआई का उपयोग करें।

ImageSearcher API की मुख्य विशेषताएं

• इनपुट के रूप में एक छवि लेता है, इंडेक्स में एम्बेडिंग निष्कर्षण और निकटतम-पड़ोसी खोज करता है।

• इनपुट इमेज प्रोसेसिंग, जिसमें रोटेशन, आकार बदलना और रंग स्थान रूपांतरण शामिल है।

• इनपुट छवि की रुचि का क्षेत्र.

आवश्यक शर्तें

ImageSearcher API का उपयोग करने से पहले, खोज करने के लिए छवियों के कस्टम कॉर्पस के आधार पर एक इंडेक्स बनाने की आवश्यकता होती है। इसे मॉडल मेकर सर्चर एपीआई का उपयोग करके ट्यूटोरियल का अनुसरण और अनुकूलन करके प्राप्त किया जा सकता है।

इसके लिए आपको आवश्यकता होगी:

• एक TFLite छवि एम्बेडर मॉडल जैसे मोबाइलनेट v3 । TensorFlow हब पर Google छवि मॉड्यूल संग्रह से अधिक पूर्व-प्रशिक्षित एम्बेडर मॉडल (उर्फ फीचर वेक्टर मॉडल) देखें।
• आपकी छवियों का संग्रह.

इस चरण के बाद, आपके पास एक स्टैंडअलोन TFLite खोजकर्ता मॉडल (उदाहरण के लिए mobilenet_v3_searcher.tflite ) होना चाहिए, जो TFLite मॉडल मेटाडेटा में संलग्न इंडेक्स के साथ मूल छवि एम्बेडर मॉडल है।

जावा में अनुमान चलाएँ

चरण 1: ग्रैडल निर्भरता और अन्य सेटिंग्स आयात करें

.tflite खोजकर्ता मॉडल फ़ाइल को एंड्रॉइड मॉड्यूल की संपत्ति निर्देशिका में कॉपी करें जहां मॉडल चलाया जाएगा। निर्दिष्ट करें कि फ़ाइल को संपीड़ित नहीं किया जाना चाहिए, और मॉड्यूल की build.gradle फ़ाइल में TensorFlow Lite लाइब्रेरी जोड़ें:

android {
    // Other settings

    // Specify tflite index file should not be compressed for the app apk
    aaptOptions {
        noCompress "tflite"
    }

}

dependencies {
    // Other dependencies

    // Import the Task Vision Library dependency (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-vision:0.4.4'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.4'
}

चरण 2: मॉडल का उपयोग करना

// Initialization
ImageSearcherOptions options =
    ImageSearcherOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setSearcherOptions(
            SearcherOptions.builder().setL2Normalize(true).build())
        .build();
ImageSearcher imageSearcher =
    ImageSearcher.createFromFileAndOptions(context, modelFile, options);

// Run inference
List<NearestNeighbor> results = imageSearcher.search(image);

ImageSearcher को कॉन्फ़िगर करने के लिए अधिक विकल्पों के लिए स्रोत कोड और javadoc देखें।

C++ में अनुमान चलाएँ

// Initialization
ImageSearcherOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
options.mutable_embedding_options()->set_l2_normalize(true);
std::unique_ptr<ImageSearcher> image_searcher = ImageSearcher::CreateFromOptions(options).value();

// Create input frame_buffer from your inputs, `image_data` and `image_dimension`.
// See more information here: tensorflow_lite_support/cc/task/vision/utils/frame_buffer_common_utils.h
std::unique_ptr<FrameBuffer> frame_buffer = CreateFromRgbRawBuffer(
      image_data, image_dimension);

// Run inference
const SearchResult result = image_searcher->Search(*frame_buffer).value();

ImageSearcher कॉन्फ़िगर करने के लिए अधिक विकल्पों के लिए स्रोत कोड देखें।

पायथन में अनुमान चलाएँ

चरण 1: TensorFlow Lite सपोर्ट Pypi पैकेज स्थापित करें।

आप निम्न कमांड का उपयोग करके TensorFlow Lite सपोर्ट Pypi पैकेज स्थापित कर सकते हैं:

pip install tflite-support

चरण 2: मॉडल का उपयोग करना

from tflite_support.task import vision

# Initialization
image_searcher = vision.ImageSearcher.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_file)
result = image_searcher.search(image)

ImageSearcher कॉन्फ़िगर करने के लिए अधिक विकल्पों के लिए स्रोत कोड देखें।

उदाहरण परिणाम

Results:
 Rank#0:
  metadata: burger
  distance: 0.13452
 Rank#1:
  metadata: car
  distance: 1.81935
 Rank#2:
  metadata: bird
  distance: 1.96617
 Rank#3:
  metadata: dog
  distance: 2.05610
 Rank#4:
  metadata: cat
  distance: 2.06347

अपने स्वयं के मॉडल और परीक्षण डेटा के साथ ImageSearcher के लिए सरल सीएलआई डेमो टूल आज़माएं।