Mit der MediaPipe-Aufgabe „Image Embedder“ können Sie eine numerische Darstellung eines Bildes erstellen, die für verschiedene ML-basierte Bildaufgaben nützlich ist. Diese Funktion wird häufig verwendet, um die Ähnlichkeit zweier Bilder mithilfe mathematischer Vergleichstechniken wie der Kosinusähnlichkeit zu vergleichen. Bei dieser Aufgabe werden Bilddaten mit einem ML-Modell als statische Daten oder als kontinuierlicher Stream verarbeitet. Die Ausgabe ist eine numerische Darstellung der Bilddaten als Liste von hochdimensionalen Feature-Vektoren, auch Einbettungsvektoren genannt, entweder in Gleitkomma- oder Quantisierungsform.
Folgen Sie einer dieser Implementierungsanleitungen für Ihre Zielplattform, um diese Aufgabe zu verwenden. In diesen plattformspezifischen Anleitungen wird eine grundlegende Implementierung dieser Aufgabe mit einem empfohlenen Modell veranschaulicht. Außerdem finden Sie Codebeispiele mit den empfohlenen Konfigurationsoptionen:
In diesem Abschnitt werden die Funktionen, Eingaben, Ausgaben und Konfigurationsoptionen dieser Aufgabe beschrieben.
Funktionen
Eingabebildverarbeitung: Die Verarbeitung umfasst Bilddrehung, Größenänderung, Normalisierung und Farbraumkonvertierung.
Eingebetteter Bereich: Die Einbettung erfolgt in einem Bereich des Bildes anstelle des gesamten Bildes.
Berechnung der Ähnlichkeit von Einbettungen: Integrierte Dienstfunktion zum Berechnen der Kosinus-Ähnlichkeit zwischen zwei Merkmalsvektoren
Quantisierung: Unterstützt die Skalarquantisierung für die Feature-Vektoren.
Aufgabeneingaben
Aufgabenausgaben
Die Eingabe kann einen der folgenden Datentypen haben:
Standbilder
Decodierte Videoframes
Live-Videofeed
Der Bild-Embedder gibt eine Liste von Einbettungen aus, die Folgendes enthält:
Einbettung: Der Merkmalsvektor selbst, entweder in Gleitkommaform oder skalar quantisiert.
Kopfindex: Der Index für den Kopf, der dieses Einbettungselement erstellt hat.
Name des Heads (optional): Der Name des Heads, der dieses Einbettungsobjekt erstellt hat.
Konfigurationsoptionen
Für diese Aufgabe gibt es die folgenden Konfigurationsoptionen:
Option
Beschreibung
Wertebereich
Standardwert
running_mode
Legt den Ausführungsmodus für die Aufgabe fest. Es gibt drei Modi:
IMAGE: Der Modus für Eingaben mit einem einzelnen Bild.
VIDEO: Der Modus für decodierte Frames eines Videos.
LIVE_STREAM: Der Modus für einen Livestream von Eingabedaten, z. B. von einer Kamera. In diesem Modus muss resultListener aufgerufen werden, um einen Listener für den asynchronen Empfang von Ergebnissen einzurichten.
{IMAGE, VIDEO, LIVE_STREAM}
IMAGE
l2_normalize
Gibt an, ob der zurückgegebene Feature-Vektor mit der L2-Norm normalisiert werden soll.
Verwenden Sie diese Option nur, wenn das Modell noch keine native TFLite-Operation vom Typ „L2_NORMALIZATION“ enthält. In den meisten Fällen ist das bereits der Fall und die L2-Normalisierung wird durch TFLite-Inferenz erreicht, sodass diese Option nicht erforderlich ist.
Boolean
False
quantize
Gibt an, ob die zurückgegebene Einbettung über die Skalarquantisierung in Bytes quantisiert werden soll. Für Einbettungen wird implizit davon ausgegangen, dass sie normiert sind. Daher hat jede Dimension garantiert einen Wert im Bereich [−1,0; 1,0]. Verwenden Sie die Option „l2_normalize“, wenn dies nicht der Fall ist.
Boolean
False
result_callback
Legt fest, dass der Ergebnisempfänger die Einbettungsergebnisse asynchron empfängt, wenn sich der Bild-Embedder im Livestream-Modus befindet. Kann nur verwendet werden, wenn der Ausführungsmodus auf LIVE_STREAM festgelegt ist.
–
Nicht festgelegt
Modelle
Für den Bild-Embedder muss ein Bild-Embedding-Modell heruntergeladen und in Ihrem Projektverzeichnis gespeichert werden. Beginnen Sie mit dem standardmäßigen, empfohlenen Modell für Ihre Zielplattform, wenn Sie mit dieser Aufgabe beginnen. Bei den anderen verfügbaren Modellen müssen in der Regel Kompromisse zwischen Leistung, Genauigkeit, Auflösung und Ressourcenanforderungen eingegangen werden. In einigen Fällen sind auch zusätzliche Funktionen verfügbar.
MobileNetV3-Modell
Diese Modellfamilie verwendet eine MobileNet V3-Architektur und wurde mit ImageNet-Daten trainiert.
Dieses Modell verwendet einen Multiplikator von 0,75 für die Tiefe (Anzahl der Funktionen) in den Convolutional-Schichten, um den Kompromiss zwischen Genauigkeit und Latenz zu optimieren. Darüber hinaus ist MobileNet V3 in zwei verschiedenen Größen verfügbar: klein und groß, um das Netzwerk an Anwendungsfälle mit wenigen oder vielen Ressourcen anzupassen.
Hier sind die Aufgaben-Benchmarks für die gesamte Pipeline, die auf den oben genannten vorab trainierten Modellen basieren. Das Latenzergebnis ist die durchschnittliche Latenz auf Pixel 6 mit CPU / GPU.
[[["Leicht verständlich","easyToUnderstand","thumb-up"],["Mein Problem wurde gelöst","solvedMyProblem","thumb-up"],["Sonstiges","otherUp","thumb-up"]],[["Benötigte Informationen nicht gefunden","missingTheInformationINeed","thumb-down"],["Zu umständlich/zu viele Schritte","tooComplicatedTooManySteps","thumb-down"],["Nicht mehr aktuell","outOfDate","thumb-down"],["Problem mit der Übersetzung","translationIssue","thumb-down"],["Problem mit Beispielen/Code","samplesCodeIssue","thumb-down"],["Sonstiges","otherDown","thumb-down"]],["Zuletzt aktualisiert: 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 |"]]
