Cohere Embed des modèles - Amazon Bedrock
Demande et réponseExemple de code

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.

Cohere Embed des modèles

Vous faites des demandes d'inférence à un Embed modèle avec InvokeModelVous avez besoin de l'identifiant du modèle que vous souhaitez utiliser. Pour obtenir l'ID du modèle, voirModèles de fondation pris en charge dans Amazon Bedrock.

Note

Amazon Bedrock ne prend pas en charge les réponses en streaming provenant de Cohere Embed modèles.

Demande et réponse

Request

Le Cohere Embed les modèles ont les paramètres d'inférence suivants. 

{
    "texts":[string],
    "input_type": "search_document|search_query|classification|clustering",
    "truncate": "NONE|START|END",
    "embedding_types": embedding_types
}

Les paramètres suivants sont obligatoires.

  • textes — 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

    Minimum Maximum

    0 textes

    96 textes
    Personnages

    Minimum Maximum

    0 caractère

    2048 caractères

  • input_type — Ajoute des jetons spéciaux pour différencier chaque type les uns 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.

Les paramètres suivants sont facultatifs :

  • tronquer — Spécifie la manière dont l'API gère les entrées supérieures à 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_types — Spécifie les types d'intégrations que vous souhaitez renvoyer. Facultatif et la valeur par défaut estNone, ce qui renvoie le type de Embed Floats réponse. Il peut s'agir d'un ou de plusieurs des types suivants :

    • float— Utilisez cette valeur pour renvoyer les intégrations flottantes par défaut.

    • int8— Utilisez cette valeur pour renvoyer des intégrations int8 signées.

    • uint8— Utilisez cette valeur pour renvoyer des intégrations int8 non signées.

    • binary— Utilisez cette valeur pour renvoyer des intégrations binaires signées.

    • ubinary— Utilisez cette valeur pour renvoyer des intégrations binaires non signées.

Pour plus d'informations, voir https://docs.cohere.com/reference/intégrer dans le Cohere .

Response

Voici la réponse body d’un appel InvokeModel :

{
    "embeddings": [
        [ <array of 1024 floats> ]
    ],
    "id": string,
    "response_type" : "embeddings_floats,
    "texts": [string]
}

La réponse body inclut les champs suivants :

  • id : identifiant de la réponse.

  • response_type — 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.

Pour plus d'informations, voir https://docs.cohere.com/reference/intégrer.

Exemple de code

Cet exemple montre comment appeler le Cohere Embed Englishmodèle.

# 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):
    """
    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.
    Returns:
        dict: The response from the model.
    """

    logger.info(
        "Generating text emdeddings with the Cohere Embed model %s", model_id)

    accept = '*/*'
    content_type = 'application/json'

    bedrock = boto3.client(service_name='bedrock-runtime')

    response = bedrock.invoke_model(
        body=body,
        modelId=model_id,
        accept=accept,
        contentType=content_type
    )

    logger.info("Successfully generated text 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")

    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)

        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")
        for i, embedding in enumerate(response_body.get('embeddings')):
            print(f"\tEmbedding {i}")
            print(*embedding)

        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()