Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Modèles Cohere Embed et Cohere Embed v4
Vous effectuez des requêtes d’inférence vers un modèle Embed à l’aide de [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html). Vous devez disposer de l’ID du modèle que vous souhaitez utiliser. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
**Note**
Amazon Bedrock ne prend pas en charge les réponses de streaming provenant des modèles Cohere Embed.
**Topics**
+ [Cohere Embed v4](model-parameters-embed-v4.md)
+ [Cohere Embed v3](model-parameters-embed-v3.md)
# Cohere Embed v4
Cohere Embed v4 est un modèle de vectorisation multimodal qui prend en charge les entrées de texte et d’image. Il peut traiter le contenu de texte et d’image entrelacé, ce qui le rend idéal pour les applications de compréhension de documents, de recherche visuelle et de récupération multimodale. Le modèle prend en charge différents types de vectorisations, notamment les formats float, int8, uint8, binaire et ubinary, avec des dimensions de sortie configurables comprises entre 256 et 1536.
L’ID du modèle pour Cohere Embed v4 est `cohere.embed-v4`.
**Notes d’utilisation supplémentaires**
+ **Longueur de contexte :** jusqu’à environ 128 000 jetons sont pris en charge ; pour RAG, les petits segments améliorent souvent la récupération et les coûts.
+ **Dimensionnement de l’image :** les images > 2 458 624 pixels sont sous-échantillonnées à cette taille ; les images < 3 136 pixels sont suréchantillonnées.
+ **Entrées entrelacées :** Privilégiez inputs.content[] pour le contenu multimodal de type page afin que le contexte textuel (par exemple, nom de fichier, entités) accompagne l’image.
**Topics**
+ [Demande et réponse](#model-parameters-embed-v4-request-response)
+ [Demande et réponse pour différents types d’entrées](#api-inference-examples-cohere-embed-v4)
+ [Exemples de code](#code-examples-cohere-embed-v4)
## Demande et réponse
------
#### [ Request ]
Type de contenu : 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"
}
```
**Parameters**
+ **input\$1type** (obligatoire) : ajoute des jetons spéciaux pour distinguer les cas d’utilisation. Autorisés : `search_document`, `search_query`, `classification`, `clustering`. Pour la recherche/RAG, intégrez votre corpus avec `search_document` et les requêtes avec `search_query`.
+ **texts** (facultatif) : tableau de chaînes à intégrer. 96 maximum par appel. Si vous utilisez `texts`, n’envoyez pas `images` dans le même appel.
+ **images** (facultatif) : tableau d’images data-URI Base64 à intégrer. 96 maximum par appel. N’envoyez pas `texts` et `images` ensemble. (Utilisez `inputs` pour le contenu entrelacé.)
+ **entrées** (facultatif ; mixed/fused modalité) — Une liste où chaque élément possède une liste de contenu de parties. Chaque partie est `{ "type": "text", "text": ... }` ou `{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }`. Envoyez du contenu entrelacé semblable à une page ici (par exemple, image de page PDF avec sous-titre/métadonnées). 96 articles maximum.
+ **embedding\$1types** (facultatif) : un ou plusieurs des éléments suivants : `float`, `int8`, `uint8`, `binary`, `ubinary`. En cas d’omission, renvoie des vectorisations flottantes.
+ **output\$1dimension** (facultatif) : sélectionnez la longueur du vecteur. Valeurs autorisées : `256`, `512`, `1024`, `1536` (par défaut `1536` si non spécifié).
+ **max\$1tokens** (facultatif) : budget de troncature par objet d’entrée. Le modèle prend en charge jusqu’à environ 128 000 jetons ; un peu plus petit pour RAG, le cas échéant.
+ **truncate** (facultatif) : comment gérer les entrées trop longues : `LEFT` supprime les jetons depuis le début ; `RIGHT` supprime les jetons depuis la fin ; `NONE` renvoie une erreur si l’entrée dépasse la limite.
**Limites et tailles**
+ Articles par demande : jusqu’à 96 images. Le type de fichier image d’origine doit être au format png, jpeg, webp ou gif et sa taille peut atteindre 5 Mo.
+ Limite de taille des demandes : environ 20 Mo de données utiles totales.
+ Nombre maximum de jetons d’entrée : 128 000 jetons maximum Les fichiers image sont convertis en jetons, et le nombre total de jetons doit être inférieur à 128 000.
+ Images : maximum 2 458 624 pixels avant sous-échantillonnage ; les images inférieures à 3 136 pixels sont suréchantillonnées. Fournissez des images en tant que `data:;base64,....`
+ Comptabilisation des jetons (par élément `inputs`) : jetons provenant d’une entrée d’image ≈ (pixels de l’image ÷ 784) x 4 Jetons provenant d’une entrée de texte et d’image entrelacés = (pixels de l’image ÷ 784) x 4 \$1 (jetons de texte)
**Conseil :** Convertissez chaque page en image et envoyez-la `inputs` avec les métadonnées de la page (par exemple, nom\$1fichier, entités) dans les parties de texte adjacentes. PDFs
------
#### [ Response ]
Type de contenu : application/json
Si vous avez demandé un seul type de vectorisation (par exemple, uniquement `float`) :
```
{
"id": "string",
"embeddings": [[ /* length = output_dimension */ ]],
"response_type": "embeddings_floats",
"texts": ["..."], // present if text was provided
"inputs": [ { "content": [ ... ] } ] // present if 'inputs' was used
}
```
Si vous avez demandé plusieurs types de vectorisations (par exemple, `["float","int8"]`) :
```
{
"id": "string",
"embeddings": {
"float": [[ ... ]],
"int8": [[ ... ]]
},
"response_type": "embeddings_by_type",
"texts": ["..."], // when text used
"inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
```
+ Le nombre de vecteurs renvoyés correspond à la longueur de votre tableau `texts` ou au nombre d’éléments `inputs`.
+ La longueur de chaque vecteur est égale à `output_dimension` (par défaut `1536`).
------
## Demande et réponse pour différents types d’entrées
**A) Page entrelacée (image \$1 légende) avec des vecteurs int8 compacts**
**Demande**
```
{
"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
}
```
**Réponse (tronquée)**
```
{
"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) Indexation de corpus en texte uniquement (float par défaut, 1536-dim)**
**Demande**
```
{
"input_type": "search_document",
"texts": [
"RAG system design patterns for insurance claims",
"Actuarial loss triangles and reserving primer"
]
}
```
**Réponse (exemple)**
```
{
"response_type": "embeddings_floats",
"embeddings": [
[0.0135, -0.0272, ...], // length 1536
[0.0047, 0.0189, ...]
]
}
```
## Exemples de code
------
#### [ 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**
+ [Demande et réponse](#model-parameters-embed-v3-request-response)
+ [Exemple de code](#api-inference-examples-cohere-embed-v3)
## Demande et réponse
------
#### [ Request ]
Les modèles Cohere Embed ont les paramètres d’inférence suivants.
```
{
"input_type": "search_document|search_query|classification|clustering|image",
"texts":[string],
"images":[image_base64_image_uri]
"truncate": "NONE|START|END",
"embedding_types": embedding_types
}
```
Les paramètres suivants sont obligatoires.
+ **texts** : tableau de chaînes que le modèle doit intégrer. Pour des performances optimales, nous recommandons de réduire la longueur de chaque texte à moins de 512 jetons. Un jeton contient environ quatre caractères.
Vous trouverez ci-dessous le texte par appel et les limites de caractères.
**Textes par appel**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-embed-v3.html)
**Caractères**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-embed-v3.html)
+ **input\$1type** : ajoute des jetons spéciaux pour différencier chaque type des autres. Vous ne devez pas mélanger différents types, sauf à des fins de recherche et de récupération. Dans ce cas, intégrez votre corpus avec le type `search_document` et les requêtes intégrées avec le type `search_query`.
+ `search_document` : dans les cas d’utilisation de la recherche, utilisez `search_document` lorsque vous codez des documents que vous stockez dans une base de données vectorielles pour les intégrations.
+ `search_query` : utilisez `search_query` lorsque vous interrogez la base de données vectorielles pour trouver les documents pertinents.
+ `classification` : utilisez `classification` lorsque vous optez pour des intégrations comme entrée dans un classificateur de texte.
+ `clustering` : utilisez `clustering` pour regrouper les intégrations.
+ `images` : il s’agit d’un tableau d’images.
+ Un tableau d’URI de données d’image que le modèle doit intégrer. Le nombre maximum d’images par appel est de 1 (c’est-à-dire que le modèle ne prend en charge qu’une seule entrée d’image).
+ L’image doit être un URI de données valide. L’image doit être au format jpeg ou png et sa taille maximale doit être de 5 Mo.
+ Une seule des « images » ou un seul des « textes » doit être fourni(e).
Les paramètres suivants sont facultatifs :
+ **truncate** : spécifie la manière dont l’API gère les entrées dont la longueur est supérieure à la longueur maximale du jeton. Utilisez l'une des options suivantes :
+ `NONE` : (par défaut) renvoie une erreur lorsque l’entrée dépasse la longueur maximale du jeton d’entrée.
+ `START` : supprime le début de l’entrée.
+ `END` : supprime la fin de l’entrée.
Si vous spécifiez `START` ou `END`, le modèle supprime l'entrée jusqu'à ce que l'entrée restante atteigne exactement la longueur maximale du jeton d'entrée correspondant au modèle.
+ **embedding\$1types** : spécifie les types de vectorisations que vous souhaitez renvoyer. Facultatif et la valeur par défaut est `None`, ce qui renvoie le type de réponse `Embed Floats`. Peut être de l’un ou plusieurs des types suivants :
+ `float` : utilisez cette valeur pour renvoyer les vectorisations flottantes par défaut.
+ `int8` : utilisez cette valeur pour renvoyer des vectorisations int8 signées.
+ `uint8` : utilisez cette valeur pour renvoyer des vectorisations int8 non signées.
+ `binary` : utilisez cette valeur pour renvoyer des vectorisations binaires signées.
+ `ubinary` : utilisez cette valeur pour renvoyer des vectorisations binaires non signées.
Pour plus d’informations, consultez [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed) dans la documentation Cohere.
------
#### [ Response ]
Voici la réponse `body` d’un appel `InvokeModel` :
```
{
"embeddings": [
[ array of 1024 floats. ]
],
"id": string,
"response_type" : "embeddings_floats,
"texts": [string],
"images": [image_description]
}
```
La réponse `body` inclut les champs suivants :
+ **id** : identifiant de la réponse.
+ **response\$1type** : type de réponse. Cette valeur est toujours `embeddings_floats`.
+ **embeddings** : tableau d’intégrations dans lequel chaque intégration est un tableau de flottants avec 1 024 éléments. La longueur du tableau `embeddings` est la même que celle du tableau `texts` d’origine.
+ **texts** : tableau contenant les entrées de texte pour lesquelles les intégrations ont été renvoyées.
+ **images** : tableau d’une description pour chaque entrée d’image.
Une `image_description`image\$1description est de la forme suivante :
```
{
"width": long,
"height": long,
"format": string,
"bit_depth": long
}
```
Si l’image a été utilisée comme entrée, le champ de réponse `“texts”` sera un tableau vide. L’inverse n’est pas vrai (c’est-à-dire que lorsque des textes sont utilisés, `“images”` ne figurera pas dans la réponse)
Pour plus d'informations, consultez [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed).
------
## Exemple de code
Cet exemple montre comment appeler le modèle *Cohere Embed English*.
```
# 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()
```
**Entrée d’image**
```
# 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()
```