A tarefa MediaPipe Text Embedder permite criar uma representação numérica de dados de texto para capturar o significado semântico deles. Essa funcionalidade é usada com frequência para comparar
a similaridade semântica de dois textos usando técnicas de comparação
matemática, como a similaridade de cosseno. Essa tarefa opera em dados de texto com um modelo de aprendizado de máquina (ML) e gera uma representação numérica dos dados de texto 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, incluindo um modelo recomendado e um exemplo de código
com 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 texto de entrada: oferece suporte à tokenização fora do gráfico para modelos
sem tokenização no gráfico.
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
O invólucro de texto aceita o seguinte tipo de dados de entrada:
String
O Text 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
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
Modelos
Oferecemos um modelo padrão recomendado quando você começa a desenvolver com essa tarefa.
("É uma viagem encantadora e muitas vezes comovente", "Que viagem incrível!")
("I like my phone", "I hate my phone")
("Este restaurante tem um grande truque", "Precisamos verificar os detalhes do nosso plano")
Os embeddings de texto nos dois primeiros pares têm uma similaridade de cosseno maior
do que os embeddings no terceiro par porque os dois primeiros pares de frases
têm um tema comum de "sentimento de viagem" e "opinião de telefone", respectivamente, enquanto
o terceiro par de frases não tem um tema comum.
Embora as duas frases do segundo par tenham sentimentos opostos,
elas têm uma alta pontuação de similaridade porque compartilham um tema comum.
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,["# Text embedding guide\n\nThe MediaPipe Text Embedder task lets you create a numeric representation of text data to\ncapture its semantic meaning. This functionality is frequently used to compare\nthe semantic similarity of two pieces of text using mathematical comparison\ntechniques such as Cosine Similarity. This task operates on text data with a\nmachine learning (ML) model, and outputs a numeric representation of the text\ndata as a list of high-dimensional feature vectors, also known as embedding\nvectors, in either floating-point or quantized form.\n\n[Try it!arrow_forward](https://mediapipe-studio.webapps.google.com/demo/text_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, including a recommended model, and code example\nwith recommended configuration options:\n\n- **Android** - [Code\n example](https://github.com/google-ai-edge/mediapipe-samples/tree/main/examples/text_embedder/android) - [Guide](./android)\n- **Python** - [Code\n example](https://colab.sandbox.google.com/github/googlesamples/mediapipe/blob/main/examples/text_embedder/python/text_embedder.ipynb) - [Guide](./python)\n- **Web** - [Code example](https://codepen.io/mediapipe-preview/pen/XWBVZmE) - [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 text processing** - Supports out-of-graph tokenization for models without in-graph tokenization.\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| Text Embedder accepts the following input data type: - String | Text 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| `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\nModels\n------\n\nWe offer a default, recommended model when you start developing with this task.\n| **Attention:** This MediaPipe Solutions Preview is an early release. [Learn more](/edge/mediapipe/solutions/about#notice).\n\n### Universal Sentence Encoder model (recommended)\n\nThis model uses a [dual encoder architecture](https://aclanthology.org/2022.emnlp-main.640.pdf)\nand was trained on various question-answer datasets.\n\nConsider the following pairs of sentences:\n\n- (\"it's a charming and often affecting journey\", \"what a great and fantastic trip\")\n- (\"I like my phone\", \"I hate my phone\")\n- (\"This restaurant has a great gimmick\", \"We need to double-check the details of our plan\")\n\nThe text embeddings in the first two pairs will have a higher cosine similarity\nthan the embeddings in the third pair because the first two pairs of sentences\nshare a common topic of \"trip sentiment\" and \"phone opinion\" respectively while\nthe third pair of sentences do not share a common topic.\n\nNote that although the two sentences in the second pair have opposing sentiments,\nthey have a high similarity score because they share a common topic.\n\n| Model name | Input shape | Quantization type | Versions |\n|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------|-------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------|\n| [Universal Sentence Encoder](https://storage.googleapis.com/mediapipe-models/text_embedder/universal_sentence_encoder/float32/latest/universal_sentence_encoder.tflite) | string, string, string | None (float32) | [Latest](https://storage.googleapis.com/mediapipe-models/text_embedder/universal_sentence_encoder/float32/latest/universal_sentence_encoder.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| Universal Sentence Encoder | 18.21ms | - |"]]