Integrar buscadores de imágenes

La búsqueda de imágenes permite buscar imágenes similares en una base de datos de imágenes. Funciona incorporando la consulta de búsqueda en un vector de alta dimensión que representa el significado semántico de la consulta, seguido de una búsqueda de similitud en un índice personalizado predefinido utilizando ScaNN (vecinos más cercanos escalables).

A diferencia de la clasificación de imágenes , ampliar la cantidad de elementos que se pueden reconocer no requiere volver a entrenar todo el modelo. Se pueden agregar nuevos elementos simplemente reconstruyendo el índice. Esto también permite trabajar con bases de datos de imágenes más grandes (más de 100.000 elementos).

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

Características clave de la API ImageSearcher

• Toma una única imagen como entrada, realiza extracción de incrustación y búsqueda del vecino más cercano en el índice.

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

Requisitos previos

Antes de utilizar la API ImageSearcher , es necesario crear un índice basado en el corpus personalizado de imágenes para buscar. Esto se puede lograr utilizando Model Maker Searcher API siguiendo y adaptando el tutorial .

Para esto necesitarás:

• un modelo de incrustación de imágenes TFLite como mobilenet v3 . Vea más modelos integrados previamente entrenados (también conocidos como modelos de vectores de características) de la colección de módulos de imágenes de Google en TensorFlow Hub .
• su corpus de imágenes.

Después de este paso, debería tener un modelo de búsqueda TFLite independiente (por ejemplo, mobilenet_v3_searcher.tflite ), que es el modelo de incrustación de imágenes original con el índice adjunto a los metadatos del modelo TFLite .

Ejecutar inferencia en Java

Paso 1: importar la dependencia de Gradle y otras configuraciones

Copie el archivo del modelo del buscador .tflite en el directorio de activos del módulo de Android donde se ejecutará el modelo. Especifique que el archivo no debe comprimirse y agregue la biblioteca TensorFlow Lite al archivo build.gradle del módulo:

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

Paso 2: usar el modelo

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

Consulte el código fuente y javadoc para obtener más opciones para configurar ImageSearcher .

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

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

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_searcher = vision.ImageSearcher.create_from_file(model_path)

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

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

Resultados de ejemplo

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

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