As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Modelos Embed e Cohere Embed v4 da Cohere
Você faz solicitações de inferência a um modelo Embed com [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) O ID do modelo que deseja usar é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
**nota**
O Amazon Bedrock não permite respostas de streaming dos modelos Embed da Cohere.
**Topics**
+ [Cohere Embed v4](model-parameters-embed-v4.md)
+ [Cohere Embed v3](model-parameters-embed-v3.md)
# Cohere Embed v4
O Cohere Embed v4 é um modelo de incorporação multimodal que comporta entradas de texto e imagem. Ele pode processar conteúdo intercalado de texto e imagem, o que o torna ideal para aplicações de compreensão de documentos, pesquisa visual e recuperação multimodal. O modelo comporta vários tipos de incorporação, como formatos float, int8, uint8, binário e ubinário, com dimensões de saída configuráveis de 256 a 1.536.
O ID de modelo do Cohere Embed v4 é `cohere.embed-v4`.
**Observações adicionais sobre o uso**
+ **Tamanho do contexto:** são aceitos aproximadamente 128 mil tokens; para RAG, fragmentos menores geralmente melhoram a recuperação e o custo.
+ **Dimensionamento da imagem:** imagens > 2.458.624 pixels têm resolução reduzida para esse tamanho; imagens com menos de 3.136 pixels são ampliadas.
+ **Entradas intercaladas:** prefira inputs.content[] para conteúdo multimodal semelhante a uma página, para que o contexto textual (p. ex., nome do arquivo, entidades) seja correlacionado à imagem.
**Topics**
+ [Solicitação e reposta](#model-parameters-embed-v4-request-response)
+ [Solicitação e resposta para diferentes input\$1types](#api-inference-examples-cohere-embed-v4)
+ [Exemplos de código](#code-examples-cohere-embed-v4)
## Solicitação e reposta
------
#### [ Request ]
Tipo de conteúdo: application/json
```
{
"input_type": "search_document | search_query | classification | clustering",
"texts": ["..."], // optional; text-only
"images": ["data:;base64,..."], // optional; image-only
"inputs": [
{ "content": [
{ "type": "text", "text": "..." },
{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }
]
}
], // optional; mixed (interleaved) text+image
"embedding_types": ["float" | "int8" | "uint8" | "binary" | "ubinary"],
"output_dimension": 256 | 512 | 1024 | 1536,
"max_tokens": 128000,
"truncate": "NONE | LEFT | RIGHT"
}
```
**Parâmetros**
+ **input\$1type**: (obrigatório) adiciona tokens especiais para distinguir casos de uso. Permitidos: `search_document`, `search_query`, `classification` e `clustering`. Para pesquisa/RAG, incorpore o corpo com `search_document` e as consultas com `search_query`.
+ **texts**: (opcional) matriz de strings a serem incorporadas. No máximo 96 por chamada. Se você usar `texts`, não envie `images` na mesma chamada.
+ **images**: (opcional) matriz de imagens data-URI em base64 para incorporar. No máximo 96 por chamada. Não envie `texts` e `images` juntos. (Use `inputs` para intercalação.)
+ **entradas** (opcional; mixed/fused modalidade) — Uma lista em que cada item tem uma lista de conteúdo de peças. Cada parte é `{ "type": "text", "text": ... }` ou `{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }`. Envie conteúdo intercalado semelhante a uma página aqui (p. ex., imagem da página em PDF \$1 legenda/metadados). Máximo de 96 itens.
+ **embedding\$1types**: (opcional) um ou mais `float`, `int8`, `uint8`, `binary` e `ubinary`. Se omitido, exibe incorporações de número flutuante.
+ **output\$1dimension**: (opcional) selecione o tamanho do vetor. Permitido: `256`, `512`, `1024` e `1536` (o padrão é `1536`, se especificado).
+ **max\$1tokens**: (opcional) limite para truncamento por objeto de entrada. O modelo comporta em torno de 128 mil tokens, no máximo, e um fragmento menor para RAG, conforme apropriado.
+ **truncate**: (opcional) como lidar com entradas de tamanho exagerado: `LEFT` descarta tokens do início; `RIGHT` descarta do final; `NONE` exibe um erro se a entrada ultrapassar o limite.
**Limites e tamanhos**
+ Itens por solicitação: até 96 imagens. O tipo de arquivo de imagem original deve estar no formato png, jpeg, webp ou gif e pode ter até 5 MB.
+ Limite de tamanho da solicitação: \$120 MB de carga útil total.
+ Máximo de tokens de entrada: 128 mil. Os arquivos de imagem são convertidos em tokens, e o total de tokens deve ser inferior a 128 mil.
+ Imagens: no máximo 2.458.624 pixels antes da redução da amostragem; imagens com menos de 3.136 pixels sobreamostradas. Forneça imagens como `data:;base64,....`
+ Contagem de tokens (por item de `inputs`): tokens de uma entrada de imagem ≈ (pixels da imagem ÷ 784) x 4 tokens de uma entrada intercalada de texto e imagem = (pixels da imagem ÷ 784) x 4 \$1 (tokens de texto).
**Dica:** Para isso PDFs, converta cada página em uma imagem e envie-a `inputs` junto com os metadados da página (por exemplo, nome\$1do\$1arquivo, entidades) em partes de texto adjacentes.
------
#### [ Response ]
Tipo de conteúdo: application/json
Se você solicitou um único tipo de incorporação (p. ex., somente `float`):
```
{
"id": "string",
"embeddings": [[ /* length = output_dimension */ ]],
"response_type": "embeddings_floats",
"texts": ["..."], // present if text was provided
"inputs": [ { "content": [ ... ] } ] // present if 'inputs' was used
}
```
Se você solicitou vários tipos de incorporação (por exemplo, `["float","int8"]`):
```
{
"id": "string",
"embeddings": {
"float": [[ ... ]],
"int8": [[ ... ]]
},
"response_type": "embeddings_by_type",
"texts": ["..."], // when text used
"inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
```
+ O número de vetores exibidos corresponde ao tamanho da matriz `texts` ou ao número de itens de `inputs`.
+ O tamanho de cada vetor é igual a `output_dimension` (o padrão é `1536`).
------
## Solicitação e resposta para diferentes input\$1types
**A) Página intercalada (imagem \$1 legenda) com vetores int8 compactos**
**Solicitação**
```
{
"input_type": "search_document",
"inputs": [
{
"content": [
{ "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{BASE64_PAGE_IMG}}"} }
]
}
],
"embedding_types": ["int8"],
"output_dimension": 512,
"truncate": "RIGHT",
"max_tokens": 128000
}
```
**Resposta (truncada)**
```
{
"id": "836a33cc-61ec-4e65-afaf-c4628171a315",
"embeddings": { "int8": [[ 7, -3, ... ]] },
"response_type": "embeddings_by_type",
"inputs": [
{ "content": [
{ "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{...}}"} }
] }
]
}
```
**B) Indexação de corpo somente de texto (número flutuante padrão: 1.536 dim)**
**Solicitação**
```
{
"input_type": "search_document",
"texts": [
"RAG system design patterns for insurance claims",
"Actuarial loss triangles and reserving primer"
]
}
```
**Resposta (amostra)**
```
{
"response_type": "embeddings_floats",
"embeddings": [
[0.0135, -0.0272, ...], // length 1536
[0.0047, 0.0189, ...]
]
}
```
## Exemplos de código
------
#### [ Text input ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-v4:0'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Mixed modalities ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
import base64
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def get_base64_image_uri(image_file_path: str, image_mime_type: str):
with open(image_file_path, "rb") as image_file:
image_bytes = image_file.read()
base64_image = base64.b64encode(image_bytes).decode("utf-8")
return f"data:{image_mime_type};base64,{base64_image}"
def generate_embeddings(model_id, body, region_name):
"""
Generate image embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
image_file_path = "image.jpg"
image_mime_type = "image/jpg"
text = "hello world"
model_id = 'cohere.embed-v4:0'
input_type = "search_document"
image_base64_uri = get_base64_image_uri(image_file_path, image_mime_type)
embedding_types = ["int8","float"]
try:
body = json.dumps({
"inputs": [
{
"content": [
{ "type": "text", "text": text },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{image_base64_uri}}"} }
]
}
],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("inputs")
for i, input in enumerate(response_body.get('inputs')):
print(f"\tinput {i}: {input}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
------
# Cohere Embed v3
**Topics**
+ [Solicitação e reposta](#model-parameters-embed-v3-request-response)
+ [Exemplo de código](#api-inference-examples-cohere-embed-v3)
## Solicitação e reposta
------
#### [ Request ]
Os modelos Embed da Cohere têm os parâmetros de inferência a seguir.
```
{
"input_type": "search_document|search_query|classification|clustering|image",
"texts":[string],
"images":[image_base64_image_uri]
"truncate": "NONE|START|END",
"embedding_types": embedding_types
}
```
Veja a seguir os parâmetros necessários.
+ **textos**: uma matriz de strings para o modelo incorporar. Para uma performance ideal, é recomendável reduzir o tamanho de cada texto para menos de 512 tokens. um token tem cerca de quatro caracteres.
Veja os limites de texto por chamada e por caracteres.
**Textos por chamada**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-embed-v3.html)
**Caracteres**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-embed-v3.html)
+ **input\$1type**: preceda tokens especiais para diferenciar um tipo do outro. Não misture tipos diferentes em conjunto, exceto ao misturar tipos para pesquisa e recuperação. Nesse caso, incorpore seu corpus com o tipo `search_document` e as consultas incorporadas com o tipo `search_query`.
+ `search_document`: em casos de uso de pesquisa, use `search_document` ao codificar documentos para incorporações que você armazena em um banco de dados de vetores.
+ `search_query`: use `search_query` ao consultar o banco de dados de vetores para encontrar documentos relevantes.
+ `classification`: use `classification` ao usar incorporações como entrada para um classificador de texto.
+ `clustering`: use `clustering` para agrupar as incorporações.
+ `images`: essa é uma matriz de imagens.
+ Uma matriz de URIs de dados de imagem para o modelo incorporar. O número máximo de imagens por chamada é 1 (ou seja, o modelo comporta apenas uma entrada de imagem).
+ A imagem deve ser um URI de dados válido. A imagem deve estar no formato image/jpeg ou image/png e ter o tamanho máximo de 5 MB.
+ Somente uma das “imagens” ou um dos “textos” deve ser fornecidos.
Veja os seguintes parâmetros opcionais:
+ **truncate**: especifica como a API lida com entradas maiores que o tamanho máximo do token. Use uma das seguintes opções:
+ `NONE`: (padrão) retorna um erro quando a entrada excede o tamanho máximo do token de entrada.
+ `START`: descarta o início da entrada.
+ `END`: descarta o final da entrada.
Se você especificar `START` ou `END`, o modelo descartará a entrada até que a entrada restante tenha exatamente o tamanho máximo do token de entrada para o modelo.
+ **embedding\$1types**: especifica os tipos de incorporação que você deseja que sejam exibidos. Opcional, e o padrão é `None`, que exibe o tipo de resposta `Embed Floats`. O tipo pode ser um ou mais dos seguintes:
+ `float`: usar esse valor para retornar as incorporações flutuantes padrão.
+ `int8`: usar esse valor para retornar incorporações int8 assinadas.
+ `uint8`: usar esse valor para retornar incorporações int8 não assinadas.
+ `binary`: usar esse valor para retornar incorporações binárias assinadas.
+ `ubinary`: usar esse valor para retornar incorporações binárias não assinadas.
Para obter mais informações, consulte [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed) na documentação da Cohere.
------
#### [ Response ]
A resposta `body` de uma chamada para `InvokeModel` é a seguinte:
```
{
"embeddings": [
[ array of 1024 floats. ]
],
"id": string,
"response_type" : "embeddings_floats,
"texts": [string],
"images": [image_description]
}
```
A resposta do `body` tem os seguintes campos:
+ **id**: um identificador para a resposta.
+ **response\$1type**: o tipo de resposta. Esse valor é sempre `embeddings_floats`.
+ **embeddings**: uma matriz de incorporações, em que cada incorporação é uma matriz de flutuadores com 1.024 elementos. O comprimento da matriz `embeddings` será igual ao comprimento da matriz `texts` original.
+ **texts**: uma matriz contendo as entradas de texto para as quais as incorporações foram retornadas.
+ **images**: uma matriz de uma descrição para cada entrada de imagem.
Uma `image_description`image\$1description tem o seguinte formato:
```
{
"width": long,
"height": long,
"format": string,
"bit_depth": long
}
```
Se a imagem foi usada como entrada, o campo de resposta `“texts”` será uma matriz vazia. O contrário não é verdadeiro (isto é, quando são usados textos, não haverá `“images”` na resposta).
Para ter mais informações, consulte [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed).
------
## Exemplo de código
Este exemplo mostra como chamar o modelo *Embed English da Cohere*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-english-v3'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
**Entrada de imagem**
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
import base64
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def get_base64_image_uri(image_file_path: str, image_mime_type: str):
with open(image_file_path, "rb") as image_file:
image_bytes = image_file.read()
base64_image = base64.b64encode(image_bytes).decode("utf-8")
return f"data:{image_mime_type};base64,{base64_image}"
def generate_image_embeddings(model_id, body, region_name):
"""
Generate image embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
image_file_path = "image.jpg"
image_mime_type = "image/jpg"
model_id = 'cohere.embed-english-v3'
input_type = "image"
images = [get_base64_image_uri(image_file_path, image_mime_type)]
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"images": images,
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_image_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```