text embeddings inference
v1.5.1
Uma solução de inferência rápida em chamas para modelos de incorporação de texto.
Referência para Baai/BGE-en-en-V1.5 em um NVIDIA A10 com um comprimento de sequência de 512 tokens:
A inferência de incorporação de texto (TEI) é um kit de ferramentas para implantar e servir modelos de incorporação de texto e classificação de sequência de texto de código aberto. O TEI permite a extração de alto desempenho para os modelos mais populares, incluindo Flagembedding, Ember, GTE e E5. TEI implementa muitos recursos como:
Atualmente, a inferência de incorporação de texto suporta modelos NOMIC, Bert, Camembert, XLM-Roberta com posições absolutas, modelo Jinabert com posições de álibi e modelos Mistral, Alibaba GTE e QWEN2 com posições de corda.
Abaixo estão alguns exemplos dos modelos atualmente suportados:
| MTEB Rank | Tamanho do modelo | Tipo de modelo | ID do modelo |
|---|---|---|---|
| 1 | 7b (muito caro) | Mistral | Salesforce/SFR-Embeting-2_R |
| 2 | 7b (muito caro) | Qwen2 | Alibaba-NLP/GTE-QWEN2-7B-INSTRUTA |
| 9 | 1.5b (caro) | Qwen2 | Alibaba-nlp/gte-qwen2-1.5b-instruct |
| 15 | 0,4b | Alibaba GTE | Alibaba-NLP/GTE-Large-en-V1.5 |
| 20 | 0,3b | Bert | Whereisai/Emirados Árabes Unidos-Large-V1 |
| 24 | 0,5b | Xlm-roberta | INTFLOAT/MULINGINGE-E5-LARGE-INSTRUTA |
| N / D | 0,1b | Nomicbert | NOMIC-AI/NOMIC-EMBED-TEXT-V1 |
| N / D | 0,1b | Nomicbert | NOMIC-AI/NOMIC-EMBED-TEXT-V1.5 |
| N / D | 0,1b | Jinabert | Jinaai/Jina-Embeddings-V2-Base-en |
| N / D | 0,1b | Jinabert | Jinaai/Jina-Embeddings-V2-BASE-Code |
Para explorar a lista dos modelos de incorporação de textos com melhor desempenho, visite a tabela de classificação MEB (MASSIVE INCEDIDA DE TEXTO DE TEXTO (MTEB).
Atualmente, a inferência de incorporação de texto suporta Camembert e modelos de classificação de sequência XLM-Roberta com posições absolutas.
Abaixo estão alguns exemplos dos modelos atualmente suportados:
| Tarefa | Tipo de modelo | ID do modelo |
|---|---|---|
| Renomear | Xlm-roberta | BAAI/BGE-RERANKER-LARGE |
| Renomear | Xlm-roberta | BAAI/BGE-RERANKER-BASE |
| Renomear | Gte | Alibaba-NLP/GTE-Multilingual-Rerranker-Base |
| Análise de sentimentos | Roberta | Samlowe/Roberta-Base-GO_emotions |
model=BAAI/bge-large-en-v1.5
volume= $PWD /data # share a volume with the Docker container to avoid downloading weights every run
docker run --gpus all -p 8080:80 -v $volume :/data --pull always ghcr.io/huggingface/text-embeddings-inference:1.5 --model-id $modelE então você pode fazer solicitações como
curl 127.0.0.1:8080/embed
-X POST
-d ' {"inputs":"What is Deep Learning?"} '
-H ' Content-Type: application/json 'Nota: Para usar as GPUs, você precisa instalar o NVIDIA Container Toolkit. Os drivers nvidia em sua máquina precisam ser compatíveis com a versão 12.2 CUDA ou superior.
Para ver todas as opções para servir seus modelos:
text-embeddings-router --help Usage: text-embeddings-router [OPTIONS]
Options:
--model-id <MODEL_ID>
The name of the model to load. Can be a MODEL_ID as listed on <https://hf.co/models> like `thenlper/gte-base`.
Or it can be a local directory containing the necessary files as saved by `save_pretrained(...)` methods of
transformers
[env: MODEL_ID=]
[default: thenlper/gte-base]
--revision <REVISION>
The actual revision of the model if you're referring to a model on the hub. You can use a specific commit id
or a branch like `refs/pr/2`
[env: REVISION=]
--tokenization-workers <TOKENIZATION_WORKERS>
Optionally control the number of tokenizer workers used for payload tokenization, validation and truncation.
Default to the number of CPU cores on the machine
[env: TOKENIZATION_WORKERS=]
--dtype <DTYPE>
The dtype to be forced upon the model
[env: DTYPE=]
[possible values: float16, float32]
--pooling <POOLING>
Optionally control the pooling method for embedding models.
If `pooling` is not set, the pooling configuration will be parsed from the model `1_Pooling/config.json` configuration.
If `pooling` is set, it will override the model pooling configuration
[env: POOLING=]
Possible values:
- cls: Select the CLS token as embedding
- mean: Apply Mean pooling to the model embeddings
- splade: Apply SPLADE (Sparse Lexical and Expansion) to the model embeddings. This option is only
available if the loaded model is a `ForMaskedLM` Transformer model
- last-token: Select the last token as embedding
--max-concurrent-requests <MAX_CONCURRENT_REQUESTS>
The maximum amount of concurrent requests for this particular deployment.
Having a low limit will refuse clients requests instead of having them wait for too long and is usually good
to handle backpressure correctly
[env: MAX_CONCURRENT_REQUESTS=]
[default: 512]
--max-batch-tokens <MAX_BATCH_TOKENS>
**IMPORTANT** This is one critical control to allow maximum usage of the available hardware.
This represents the total amount of potential tokens within a batch.
For `max_batch_tokens=1000`, you could fit `10` queries of `total_tokens=100` or a single query of `1000` tokens.
Overall this number should be the largest possible until the model is compute bound. Since the actual memory
overhead depends on the model implementation, text-embeddings-inference cannot infer this number automatically.
[env: MAX_BATCH_TOKENS=]
[default: 16384]
--max-batch-requests <MAX_BATCH_REQUESTS>
Optionally control the maximum number of individual requests in a batch
[env: MAX_BATCH_REQUESTS=]
--max-client-batch-size <MAX_CLIENT_BATCH_SIZE>
Control the maximum number of inputs that a client can send in a single request
[env: MAX_CLIENT_BATCH_SIZE=]
[default: 32]
--auto-truncate
Automatically truncate inputs that are longer than the maximum supported size
Unused for gRPC servers
[env: AUTO_TRUNCATE=]
--default-prompt-name <DEFAULT_PROMPT_NAME>
The name of the prompt that should be used by default for encoding. If not set, no prompt will be applied.
Must be a key in the `sentence-transformers` configuration `prompts` dictionary.
For example if ``default_prompt_name`` is "query" and the ``prompts`` is {"query": "query: ", ...}, then the
sentence "What is the capital of France?" will be encoded as "query: What is the capital of France?" because
the prompt text will be prepended before any text to encode.
The argument '--default-prompt-name <DEFAULT_PROMPT_NAME>' cannot be used with '--default-prompt <DEFAULT_PROMPT>`
[env: DEFAULT_PROMPT_NAME=]
--default-prompt <DEFAULT_PROMPT>
The prompt that should be used by default for encoding. If not set, no prompt will be applied.
For example if ``default_prompt`` is "query: " then the sentence "What is the capital of France?" will be
encoded as "query: What is the capital of France?" because the prompt text will be prepended before any text
to encode.
The argument '--default-prompt <DEFAULT_PROMPT>' cannot be used with '--default-prompt-name <DEFAULT_PROMPT_NAME>`
[env: DEFAULT_PROMPT=]
--hf-api-token <HF_API_TOKEN>
Your HuggingFace hub token
[env: HF_API_TOKEN=]
--hostname <HOSTNAME>
The IP address to listen on
[env: HOSTNAME=]
[default: 0.0.0.0]
-p, --port <PORT>
The port to listen on
[env: PORT=]
[default: 3000]
--uds-path <UDS_PATH>
The name of the unix socket some text-embeddings-inference backends will use as they communicate internally
with gRPC
[env: UDS_PATH=]
[default: /tmp/text-embeddings-inference-server]
--huggingface-hub-cache <HUGGINGFACE_HUB_CACHE>
The location of the huggingface hub cache. Used to override the location if you want to provide a mounted disk
for instance
[env: HUGGINGFACE_HUB_CACHE=]
--payload-limit <PAYLOAD_LIMIT>
Payload size limit in bytes
Default is 2MB
[env: PAYLOAD_LIMIT=]
[default: 2000000]
--api-key <API_KEY>
Set an api key for request authorization.
By default the server responds to every request. With an api key set, the requests must have the Authorization
header set with the api key as Bearer token.
[env: API_KEY=]
--json-output
Outputs the logs in JSON format (useful for telemetry)
[env: JSON_OUTPUT=]
--otlp-endpoint <OTLP_ENDPOINT>
The grpc endpoint for opentelemetry. Telemetry is sent to this endpoint as OTLP over gRPC. e.g. `http://localhost:4317`
[env: OTLP_ENDPOINT=]
--otlp-service-name <OTLP_SERVICE_NAME>
The service name for opentelemetry. e.g. `text-embeddings-inference.server`
[env: OTLP_SERVICE_NAME=]
[default: text-embeddings-inference.server]
--cors-allow-origin <CORS_ALLOW_ORIGIN>
Unused for gRPC servers
[env: CORS_ALLOW_ORIGIN=]
TEXTO INCEDIDAS Navios de inferência com várias imagens do Docker que você pode usar para segmentar um back -end específico:
| Arquitetura | Imagem |
|---|---|
| CPU | ghcr.io/huggingface/text-embeddings-inference:cpu-1.5 |
| Volta | Não suportado |
| Turing (T4, RTX 2000 Series, ...) | ghcr.io/huggingface/text-embeddings-Inference:Turing-1.5 (Experimental) |
| Ampere 80 (A100, A30) | ghcr.io/huggingface/text-embeddings-Inference:1.5 |
| Ampere 86 (A10, A40, ...) | ghcr.io/huggingface/text-embeddings-Inference:86-1.5 |
| Ada Lovelace (série RTX 4000, ...) | ghcr.io/huggingface/text-embeddings-Inference:89-1.5 |
| Hopper (H100) | ghcr.io/huggingface/text-embeddings-Inference:hopper-1.5 (experimental) |
Aviso : a atenção do flash é desligada por padrão para a imagem de Turing, pois sofre de problemas de precisão. Você pode ativar a atenção do flash v1 usando a variável USE_FLASH_ATTENTION=True ambiente.
Você pode consultar a documentação do OpenAPI da API REST da text-embeddings-inference usando a rota /docs . A interface do usuário do Swagger também está disponível em: https://huggingface.github.io/text-embeddings-Inference.
Você tem a opção de utilizar a variável de ambiente HF_API_TOKEN para configurar o token empregado pela text-embeddings-inference . Isso permite obter acesso a recursos protegidos.
Por exemplo:
HF_API_TOKEN=<your cli READ token>ou com Docker:
model= < your private model >
volume= $PWD /data # share a volume with the Docker container to avoid downloading weights every run
token= < your cli READ token >
docker run --gpus all -e HF_API_TOKEN= $token -p 8080:80 -v $volume :/data --pull always ghcr.io/huggingface/text-embeddings-inference:1.5 --model-id $modelPara implantar a inferência de incorporação de texto em um ambiente de ar, primeiro faça o download dos pesos e depois monte-os dentro do recipiente usando um volume.
Por exemplo:
# (Optional) create a `models` directory
mkdir models
cd models
# Make sure you have git-lfs installed (https://git-lfs.com)
git lfs install
git clone https://huggingface.co/Alibaba-NLP/gte-base-en-v1.5
# Set the models directory as the volume path
volume= $PWD
# Mount the models directory inside the container with a volume and set the model ID
docker run --gpus all -p 8080:80 -v $volume :/data --pull always ghcr.io/huggingface/text-embeddings-inference:1.5 --model-id /data/gte-base-en-v1.5 text-embeddings-inference V0.4.0 Adicionado suporte aos modelos de classificação de sequência de Camembert, Roberta, XLM-Roberta e GTE. Os modelos de re-jogadores são modelos de codificadores de classificação de sequência com uma única classe que obtém a semelhança entre uma consulta e um texto.
Veja este post do blog da equipe Llandeindex para entender como você pode usar os modelos de re-classificadores em seu pipeline RAG para melhorar o desempenho a jusante.
model=BAAI/bge-reranker-large
volume= $PWD /data # share a volume with the Docker container to avoid downloading weights every run
docker run --gpus all -p 8080:80 -v $volume :/data --pull always ghcr.io/huggingface/text-embeddings-inference:1.5 --model-id $modelE então você pode classificar a semelhança entre uma consulta e uma lista de textos com:
curl 127.0.0.1:8080/rerank
-X POST
-d ' {"query": "What is Deep Learning?", "texts": ["Deep Learning is not...", "Deep learning is..."]} '
-H ' Content-Type: application/json ' Você também pode usar modelos de classificação de sequência clássicos como SamLowe/roberta-base-go_emotions :
model=SamLowe/roberta-base-go_emotions
volume= $PWD /data # share a volume with the Docker container to avoid downloading weights every run
docker run --gpus all -p 8080:80 -v $volume :/data --pull always ghcr.io/huggingface/text-embeddings-inference:1.5 --model-id $model Depois de implantar o modelo, você pode usar o endpoint predict para obter as emoções mais associadas a uma entrada:
curl 127.0.0.1:8080/predict
-X POST
-d ' {"inputs":"I like you."} '
-H ' Content-Type: application/json 'Você pode optar por ativar o pool splade para Bert e Distilbert Maskedlm Architecturas:
model=naver/efficient-splade-VI-BT-large-query
volume= $PWD /data # share a volume with the Docker container to avoid downloading weights every run
docker run --gpus all -p 8080:80 -v $volume :/data --pull always ghcr.io/huggingface/text-embeddings-inference:1.5 --model-id $model --pooling splade Depois de implantar o modelo, você pode usar o endpoint /embed_sparse para obter a incorporação esparsa:
curl 127.0.0.1:8080/embed_sparse
-X POST
-d ' {"inputs":"I like you."} '
-H ' Content-Type: application/json ' text-embeddings-inference é instrumentada com rastreamento distribuído usando o Opentelemetria. Você pode usar esse recurso definindo o endereço como um coletor OTLP com o argumento --otlp-endpoint .
text-embeddings-inference oferece uma API GRPC como uma alternativa à API HTTP padrão para implantações de alto desempenho. A definição da API Protobuf pode ser encontrada aqui.
Você pode usar a API GRPC adicionando a tag -grpc a qualquer imagem do TEI Docker. Por exemplo:
model=BAAI/bge-large-en-v1.5
volume= $PWD /data # share a volume with the Docker container to avoid downloading weights every run
docker run --gpus all -p 8080:80 -v $volume :/data --pull always ghcr.io/huggingface/text-embeddings-inference:1.5-grpc --model-id $model grpcurl -d ' {"inputs": "What is Deep Learning"} ' -plaintext 0.0.0.0:8080 tei.v1.Embed/Embed Você também pode optar por instalar text-embeddings-inference localmente.
Primeiro instalar ferrugem:
curl --proto ' =https ' --tlsv1.2 -sSf https://sh.rustup.rs | shEm seguida, corra:
# On x86
cargo install --path router -F mkl
# On M1 or M2
cargo install --path router -F metalAgora você pode iniciar a inferência de incorporação de texto na CPU com:
model=BAAI/bge-large-en-v1.5
text-embeddings-router --model-id $model --port 8080Nota: Em algumas máquinas, você também pode precisar das bibliotecas OpenSSL e GCC. Nas máquinas Linux, execute:
sudo apt-get install libssl-dev gcc -yGPUs com recursos de computação CUDA <7,5 não são suportados (V100, Titan V, GTX 1000 Series, ...).
Verifique se você tem CUDA e os drivers da NVIDIA instalados. Os drivers nvidia no seu dispositivo precisam ser compatíveis com a versão 12.2 CUDA ou superior. Você também precisa adicionar os binários da NVIDIA ao seu caminho:
export PATH= $PATH :/usr/local/cuda/binEm seguida, corra:
# This can take a while as we need to compile a lot of cuda kernels
# On Turing GPUs (T4, RTX 2000 series ... )
cargo install --path router -F candle-cuda-turing -F http --no-default-features
# On Ampere and Hopper
cargo install --path router -F candle-cuda -F http --no-default-featuresAgora você pode iniciar a inferência de incorporação de texto na GPU com:
model=BAAI/bge-large-en-v1.5
text-embeddings-router --model-id $model --port 8080Você pode construir o contêiner da CPU com:
docker build .Para construir os contêineres CUDA, você precisa conhecer o limite de computação da GPU que você usará no tempo de execução.
Então você pode construir o contêiner com:
# Example for Turing (T4, RTX 2000 series, ...)
runtime_compute_cap=75
# Example for A100
runtime_compute_cap=80
# Example for A10
runtime_compute_cap=86
# Example for Ada Lovelace (RTX 4000 series, ...)
runtime_compute_cap=89
# Example for H100
runtime_compute_cap=90
docker build . -f Dockerfile-cuda --build-arg CUDA_COMPUTE_CAP= $runtime_compute_capComo explicado aqui MPS pronto para MPS, a imagem do Docker do ARM64, o Metal / MPS não é suportado via Docker. Como tal, a inferência será ligada à CPU e provavelmente bem lenta ao usar essa imagem do Docker em uma CPU de braço M1/M2.
docker build . -f Dockerfile --platform=linux/arm64
