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

  Minimum	Maximum
  0 texte	96 textes

  Caractères

  Minimum	Maximum
  0 caractère	2048 caractères

• input_type : 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_types : 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 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_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.

• images : tableau d’une description pour chaque entrée d’image.

  Une image_descriptionimage_description 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.

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