Integrar incrustadores de imágenes

Los incrustadores de imágenes permiten incrustar imágenes en un vector de características de alta dimensión que representa el significado semántico de una imagen, que luego se puede comparar con el vector de características de otras imágenes para evaluar su similitud semántica.

A diferencia de la búsqueda de imágenes , el incrustador de imágenes permite calcular la similitud entre imágenes sobre la marcha en lugar de buscar a través de un índice predefinido creado a partir de un corpus de imágenes.

Utilice la API ImageEmbedder de la biblioteca de tareas para implementar su incrustador de imágenes personalizado en sus aplicaciones móviles.

Características clave de la API ImageEmbedder

• Procesamiento de imágenes de entrada, incluida la rotación, el cambio de tamaño y la conversión del espacio de color.

• Región de interés de la imagen de entrada.

• Función de utilidad incorporada para calcular la similitud del coseno entre vectores de características.

Modelos de incrustación de imágenes compatibles

Se garantiza que los siguientes modelos serán compatibles con la API ImageEmbedder .

• Presenta modelos vectoriales de la colección de módulos de imágenes de Google en TensorFlow Hub .

• Modelos personalizados que cumplen con los requisitos de compatibilidad de modelos .

Ejecutar inferencia 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());

Consulte el código fuente para obtener más opciones para configurar ImageEmbedder .

Ejecutar inferencia en Python

Paso 1: Instale el paquete Pypi de soporte de TensorFlow Lite.

Puede instalar el paquete Pypi de soporte de TensorFlow Lite usando el siguiente comando:

pip install tflite-support

Paso 2: usar el modelo

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)

Consulte el código fuente para obtener más opciones para configurar ImageEmbedder .

Resultados de ejemplo

La similitud de coseno entre vectores de características normalizados devuelve una puntuación entre -1 y 1. Cuanto más alto, mejor, es decir, una similitud de coseno de 1 significa que los dos vectores son idénticos.

Cosine similarity: 0.954312

Pruebe la sencilla herramienta de demostración CLI para ImageEmbedder con su propio modelo y datos de prueba.

Requisitos de compatibilidad del modelo

La API ImageEmbedder espera un modelo TFLite con metadatos del modelo TFLite opcionales, pero muy recomendados.

Los modelos de incrustación de imágenes compatibles deben cumplir los siguientes requisitos:

• Un tensor de imagen de entrada (kTfLiteUInt8/kTfLiteFloat32)

  • entrada de imagen de tamaño [batch x height x width x channels] .
  • No se admite la inferencia por lotes (se requiere que batch sea 1).
  • Solo se admiten entradas RGB (se requieren 3 channels ).
  • si el tipo es kTfLiteFloat32, es necesario adjuntar NormalizationOptions a los metadatos para la normalización de la entrada.

• Al menos un tensor de salida (kTfLiteUInt8/kTfLiteFloat32)

  • con N componentes correspondientes a las N dimensiones del vector de características devuelto para esta capa de salida.
  • 2 o 4 dimensiones, es decir [1 x N] o [1 x 1 x 1 x N] .