Intégrer des intégrateurs d'images

Les représentations vectorielles continues d'images permettent d'intégrer des images dans un vecteur de caractéristiques de grande dimension représentant la signification sémantique d'une image, que vous pouvez ensuite comparer le vecteur de caractéristiques d'autres images pour évaluer leur similarité sémantique.

Par opposition à recherche d'images, L'outil d'intégration d'images permet de calculer la similarité entre les images à la volée. au lieu d'effectuer une recherche dans un index prédéfini construit à partir d'un corpus d'images.

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

Principales fonctionnalités de l'API ImageEmbedder

  • 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.

  • Fonction utilitaire intégrée permettant de calculer le similarité cosinus entre des vecteurs de caractéristiques.

Modèles de représentations vectorielles continues compatibles

La compatibilité des modèles suivants avec ImageEmbedder est garantie. API.

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

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

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

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

Exemples de résultats

La similarité cosinus entre les vecteurs de caractéristiques normalisés renvoie un score compris entre -1 et 1. Plus elle est élevée, mieux c'est. En d'autres termes, une similarité cosinus de 1 signifie que les deux vecteurs identiques.

Cosine similarity: 0.954312

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

Exigences de compatibilité des modèles

L'API ImageEmbedder attend un modèle TFLite avec un paramètre facultatif, mais fortement recommandé Métadonnées du modèle TFLite.

Les modèles d'intégration d'images compatibles doivent répondre aux exigences suivantes:

  • Tensor d'image d'entrée (kTfLiteUInt8/kTfLiteFloat32)

    • Entrée d'image de taille [batch x height x width x channels].
    • l'inférence par lot n'est pas acceptée (batch doit être défini sur 1).
    • Seules les entrées RVB sont acceptées (la valeur de channels doit être 3).
    • Si le type est kTfLiteFloat32, les options de normalisation doivent être aux métadonnées pour la normalisation des entrées.

  • Au moins un Tensor de sortie (kTfLiteUInt8/kTfLiteFloat32)

    • avec des composants N correspondant aux dimensions N des éléments renvoyés vecteur de caractéristiques de cette couche de sortie.
    • Deux ou quatre dimensions ([1 x N] ou [1 x 1 x 1 x N], par exemple).