A tarefa de incorporação de imagem do MediaPipe permite criar uma representação numérica de uma imagem,
o que é útil para realizar várias tarefas de imagem baseadas em ML. Essa
funcionalidade é usada com frequência para comparar a similaridade de duas imagens usando
técnicas de comparação matemática, como a similaridade de cosseno. Essa tarefa opera
em dados de imagem com um modelo de aprendizado de máquina (ML) como dados estáticos ou um fluxo
contínuo e gera uma representação numérica dos dados de imagem como uma lista de
vetores de características de alta dimensão, também conhecidos como vetores de embeddings, em
formato de ponto flutuante ou quantizado.
Para começar a usar essa tarefa, siga um destes guias de implementação para sua
plataforma de destino. Estes guias específicos para plataformas orientam você em uma implementação
básica desta tarefa, usando um modelo recomendado, e fornecem exemplos
de código com as opções de configuração recomendadas:
Esta seção descreve os recursos, entradas, saídas e opções de configuração
desta tarefa.
Recursos
Processamento de imagem de entrada: o processamento inclui rotação, redimensionamento,
normalização e conversão de espaço de cores.
Região de interesse: realiza a incorporação em uma região da imagem em vez
de toda a imagem.
Cálculo de similaridade de embedding: função utilitária integrada para calcular
a semelhança de cosseno
entre dois vetores de recursos.
Quantização: oferece suporte à quantização escalar para os vetores de atributos.
Entradas da tarefa
Saídas de tarefas
A entrada pode ser um dos seguintes tipos de dados:
Imagens estáticas
Frames de vídeo decodificados
Feed de vídeo ao vivo
O Image Embedder gera uma lista de embeddings que consistem em:
Embedding: o próprio vetor de características, seja na forma de ponto flutuante ou
quantizado por escalar.
Índice da cabeça: o índice da cabeça que produziu esse embedding.
Nome da cabeça (opcional): o nome da cabeça que produziu a incorporação.
Opções de configuração
Esta tarefa tem as seguintes opções de configuração:
Nome da opção
Descrição
Intervalo de valor
Valor padrão
running_mode
Define o modo de execução da tarefa. Há três
modos:
IMAGE: o modo para entradas de imagem única.
VÍDEO: o modo para quadros decodificados de um vídeo.
LIVE_STREAM: o modo de uma transmissão ao vivo de dados
de entrada, como de uma câmera. Nesse modo, o resultListener precisa ser
chamado para configurar um listener para receber resultados
de forma assíncrona.
{IMAGE, VIDEO, LIVE_STREAM}
IMAGE
l2_normalize
Se o vetor de recursos retornado vai ser normalizado com a norma L2.
Use essa opção somente se o modelo ainda não tiver uma operação TFLite
L2_NORMALIZATION nativa. Na maioria dos casos, isso já acontece e
a normalização L2 é alcançada pela inferência do TFLite sem a necessidade
dessa opção.
Boolean
False
quantize
Indica se o embedding retornado precisa ser quantizado em bytes por meio de
quantização escalar. As inclusões são implicitamente consideradas como unidade-norm e,
portanto, qualquer dimensão tem garantia de ter um valor em [-1,0, 1,0]. Use
a opção l2_normalize se não for esse o caso.
Boolean
False
result_callback
Define o listener de resultado para receber os resultados de incorporação
de forma assíncrona quando o incorporador de imagem está no modo de transmissão
ao vivo. Só pode ser usado quando o modo de execução está definido como LIVE_STREAM.
N/A
Não definido
Modelos
O Image Embedder exige que um modelo de embedding de imagem seja transferido por download e armazenado
no diretório do projeto. Comece com o modelo padrão recomendado para sua
plataforma de destino ao começar a desenvolver com essa tarefa. Os outros modelos disponíveis
geralmente fazem compensações entre desempenho, precisão, resolução e
requisitos de recursos e, em alguns casos, incluem recursos adicionais.
Modelo MobileNetV3
Essa família de modelos usa uma arquitetura MobileNet V3
e foi treinada com dados do ImageNet.
Esse modelo usa um multiplicador de 0,75 para a profundidade (número de recursos) nas
camadas convolucionais para ajustar o trade-off entre precisão e latência. Além disso,
a MobileNet V3 tem dois tamanhos diferentes, pequeno e grande, para adaptar a rede
a casos de uso de recursos baixos ou altos.
Confira os comparativos de mercado da tarefa para todo o pipeline com base nos modelos pré-treinados
acima. O resultado da latência é a latência média no Pixel 6 usando
CPU / GPU.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Não contém as informações de que eu preciso","missingTheInformationINeed","thumb-down"],["Muito complicado / etapas demais","tooComplicatedTooManySteps","thumb-down"],["Desatualizado","outOfDate","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Problema com as amostras / o código","samplesCodeIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 2025-01-13 UTC."],[],[],null,["# Image embedding task guide\n\nThe MediaPipe Image Embedder task lets you create a numeric representation of an image,\nwhich is useful in accomplishing various ML-based image tasks. This\nfunctionality is frequently used to compare the similarity of two images using\nmathematical comparison techniques such as Cosine Similarity. This task operates\non image data with a machine learning (ML) model as static data or a continuous\nstream, and outputs a numeric representation of the image data as a list of\nhigh-dimensional feature vectors, also known as embedding vectors, in either\nfloating-point or quantized form.\n\n[Try it!arrow_forward](https://mediapipe-studio.webapps.google.com/demo/image_embedder)\n\nGet Started\n-----------\n\nStart using this task by following one of these implementation guides for your\ntarget platform. These platform-specific guides walk you through a basic\nimplementation of this task, using a recommended model, and provide code\nexamples with the recommended configuration options:\n\n- **Android** - [Code\n example](https://github.com/google-ai-edge/mediapipe-samples/tree/main/examples/image_embedder/android) - [Guide](./android)\n- **Python** - [Code\n example](https://colab.sandbox.google.com/github/googlesamples/mediapipe/blob/main/examples/image_embedder/python/image_embedder.ipynb) - [Guide](./python)\n- **Web** - [Code example](https://codepen.io/mediapipe-preview/pen/yLqxbaZ) - [Guide](./web_js)\n\nTask details\n------------\n\nThis section describes the capabilities, inputs, outputs, and configuration\noptions of this task.\n\n### Features\n\n- **Input image processing** - Processing includes image rotation, resizing, normalization, and color space conversion.\n- **Region of interest** - Performs embedding on a region of the image instead of the whole image.\n- **Embedding similarity computation** - Built-in utility function to compute the [cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity) between two feature vectors\n- **Quantization** - Supports scalar quantization for the feature vectors.\n\n| Task inputs | Task outputs |\n|-------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| Input can be one of the following data types: - Still images \u003c!-- --\u003e - Decoded video frames \u003c!-- --\u003e - Live video feed | Image Embedder outputs a list of embeddings consisting of: - Embedding: the feature vector itself, either in floating-point form or scalar-quantized. \u003c!-- --\u003e - Head index: the index for the head that produced this embedding. \u003c!-- --\u003e - Head name (optional): the name of the head that produced this embedding. |\n\n### Configurations options\n\nThis task has the following configuration options:\n\n| Option Name | Description | Value Range | Default Value |\n|-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------|---------------|\n| `running_mode` | Sets the running mode for the task. There are three modes: \u003cbr /\u003e IMAGE: The mode for single image inputs. \u003cbr /\u003e VIDEO: The mode for decoded frames of a video. \u003cbr /\u003e LIVE_STREAM: The mode for a livestream of input data, such as from a camera. In this mode, resultListener must be called to set up a listener to receive results asynchronously. | {`IMAGE, VIDEO, LIVE_STREAM`} | `IMAGE` |\n| `l2_normalize` | Whether to normalize the returned feature vector with L2 norm. Use this option only if the model does not already contain a native L2_NORMALIZATION TFLite Op. In most cases, this is already the case and L2 normalization is thus achieved through TFLite inference with no need for this option. | `Boolean` | `False` |\n| `quantize` | Whether the returned embedding should be quantized to bytes via scalar quantization. Embeddings are implicitly assumed to be unit-norm and therefore any dimension is guaranteed to have a value in \\[-1.0, 1.0\\]. Use the l2_normalize option if this is not the case. | `Boolean` | `False` |\n| `result_callback` | Sets the result listener to receive the embedding results asynchronously when the Image Embedder is in the live stream mode. Can only be used when running mode is set to `LIVE_STREAM` | N/A | Not set |\n\n| **Note:** The `resultListener` is dependent on `runningMode`. Only set the `resultListener` when `runningMode` is set to `LIVE_STREAM`.\n\nModels\n------\n\nThe Image Embedder requires an image embedding model to be downloaded and stored\nin your project directory. Start with the default, recommended model for your\ntarget platform when you start developing with this task. The other available\nmodels typically make trade-offs between performance, accuracy, resolution, and\nresource requirements, and in some cases, include additional features.\n| **Attention:** This MediaPipe Solutions Preview is an early release. [Learn more](/edge/mediapipe/solutions/about#notice).\n\n### MobileNetV3 model\n\nThis model family uses a [MobileNet V3](https://arxiv.org/abs/1905.02244)\narchitecture and was trained using [ImageNet](https://www.image-net.org) data.\nThis model uses a multiplier of 0.75 for the depth (number of features) in the\nconvolutional layers to tune the accuracy-latency trade off. In addition,\nMobileNet V3 comes in two different sizes, small and large, to adapt the network\nto low or high resource use cases.\n\n| Model name | Input shape | Quantization type | Versions |\n|----------------------------------------------------------------------------------------------------------------------------------------------------|-------------|-------------------|--------------------------------------------------------------------------------------------------------------------------------------|\n| [MobileNet-V3 (small)](https://storage.googleapis.com/mediapipe-models/image_embedder/mobilenet_v3_small/float32/latest/mobilenet_v3_small.tflite) | 224 x 224 | None (float32) | [Latest](https://storage.googleapis.com/mediapipe-models/image_embedder/mobilenet_v3_small/float32/latest/mobilenet_v3_small.tflite) |\n| [MobileNet-V3 (large)](https://storage.googleapis.com/mediapipe-models/image_embedder/mobilenet_v3_large/float32/latest/mobilenet_v3_large.tflite) | 224 x 224 | None (float32) | [Latest](https://storage.googleapis.com/mediapipe-models/image_embedder/mobilenet_v3_large/float32/latest/mobilenet_v3_large.tflite) |\n\nTask benchmarks\n---------------\n\nHere's the task benchmarks for the whole pipeline based on the above\npre-trained models. The latency result is the average latency on Pixel 6 using\nCPU / GPU.\n\n| Model Name | CPU Latency | GPU Latency |\n|----------------------|-------------|-------------|\n| MobileNet-V3 (small) | 3.94ms | 7.83ms |\n| MobileNet-V3 (large) | 9.75ms | 9.08ms |"]]
