Intégrer des outils de recherche d'images

La recherche d'images permet de rechercher des images similaires dans une base de données d'images. Il intègre la requête de recherche dans un vecteur de grande dimension représentant la signification sémantique de la requête, suivie d'une recherche par similarité un index prédéfini et personnalisé ScaNN (Voisins les plus proches évolutifs).

Par opposition à classification d'images l'augmentation du nombre d'éléments pouvant être reconnus n'a pas besoin d'être réentraîné. l'ensemble du modèle. De nouveaux éléments peuvent être ajoutés simplement en reconstruisant l'index. De plus, permet de travailler avec des bases de données d'images plus volumineuses (plus de 100 000 éléments).

Déployer votre outil de recherche d'images personnalisé à l'aide de l'API ImageSearcher de la bibliothèque de tâches dans vos applications mobiles.

Principales fonctionnalités de l'API ImageSearcher

Prend une seule image en entrée, extrait une représentation vectorielle continue et la recherche du voisin le plus proche dans l'index.
Traitement de l'image d'entrée, y compris la rotation, le redimensionnement et l'espace colorimétrique la conversion.
Région d'intérêt de l'image d'entrée.

Prérequis

Avant d'utiliser l'API ImageSearcher, vous devez créer un index basé sur le un corpus personnalisé d'images dans lesquelles effectuer la recherche. Pour ce faire, vous pouvez utiliser API Model Maker Searcher en suivant et en adaptant tutoriel.

Pour cela, vous aurez besoin des éléments suivants:

un modèle de intégrateur d'images TFLite tel que mobilenet v3. Découvrez d'autres modèles de représentations vectorielles continues pré-entraînés (également appelés modèles de vecteur de caractéristiques) dans la Collection de modules d'image Google sur les modèles Kaggle.
votre corpus d'images.

Après cette étape, vous devez disposer d'un modèle de recherche TFLite autonome (par exemple, mobilenet_v3_searcher.tflite), qui est le modèle d'intégration d'images d'origine avec l'index associé au Métadonnées du modèle TFLite.

Exécuter une inférence en Java

Étape 1: Importez la dépendance Gradle et d'autres paramètres

Copiez le fichier de modèle du moteur de recherche .tflite dans le répertoire d'éléments d'Android. module dans lequel le modèle sera exécuté. Spécifiez que le fichier ne doit pas compressé, puis ajoutez la bibliothèque TensorFlow Lite au fichier build.gradle du module. :

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

Étape 2: Utiliser le modèle

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

Consultez le Code source et Javadoc pour découvrir d'autres options de configuration de ImageSearcher.

Exécuter une inférence en 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();

Consultez le code source pour afficher d'autres options de configuration de ImageSearcher.

Exécuter une inférence en Python

Étape 1: Installez le package Pypi de support TensorFlow Lite.

Vous pouvez installer le package Pypi de support TensorFlow Lite à l'aide de la commande suivante : :

pip install tflite-support

Étape 2: Utiliser le modèle

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)

Consultez le code source pour afficher d'autres options de configuration de ImageSearcher.

Exemples de résultats

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

Essayez la méthode la plus simple Outil de démonstration de la CLI pour ImageSearcher avec votre propre modèle et vos données de test.