Cohere Embed Modelos de

Realiza solicitudes de inferencia a un Embed modelo con InvokeModelNecesita el ID de modelo del modelo que quiere usar. Para obtener el ID del modelo, consulte Modelos fundacionales compatibles en Amazon Bedrock.

nota

Amazon Bedrock no admite la transmisión de respuestas de Cohere Embed modelos.

Solicitud y respuesta

Request

La Cohere Embed los modelos tienen los siguientes parámetros de inferencia.

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

Los siguientes parámetros son obligatorios.

• texts: una matriz de cadenas para que el modelo las incruste. Para un rendimiento óptimo, recomendamos reducir la longitud de cada texto a menos de 512 tokens. 1 token tiene unos 4 caracteres.

  Los siguientes son los límites de texto por llamada y de caracteres.

  Textos por llamada

  Mínimo	Máximo
  0 textos	96 textos

  Caracteres

  Mínimo	Máximo
  0 caracteres	2048 caracteres

• input_type: antepone tokens especiales para diferenciar cada tipo entre sí. No se deben mezclar tipos diferentes, excepto cuando se mezclan tipos para la búsqueda y la recuperación. En este caso, incruste el corpus con el tipo search_document y las consultas incrustadas con el tipo search_query.

  • search_document: en los casos de uso de búsquedas, use search_document cuando codifique documentos para incrustarlos y guardarlos en una base de datos vectorial.

  • search_query: use search_query al consultar su base de datos vectorial para encontrar documentos relevantes.

  • classification: use classification cuando utilice incrustaciones como entrada a un clasificador de texto.

  • clustering: use clustering para agrupar las incrustaciones.

Los siguientes parámetros son opcionales:

• truncar: especifica cómo API gestiona las entradas que superan la longitud máxima del token. Utilice una de las siguientes:

  • NONE: (predeterminado) devuelve un error cuando la entrada supera la longitud máxima del token de entrada.

  • START: descarta el inicio de la entrada.

  • END: descarta el final de la entrada.

  Si especifica START oEND, el modelo descarta la entrada hasta que la entrada restante tenga exactamente la longitud máxima del token de entrada para el modelo.

• embedding_types: especifica los tipos de incrustaciones que desea que se devuelvan. Es opcional pero el valor predeterminado es None, que devuelve el tipo de respuesta Embed Floats. Puede tratarse de uno o más de los siguientes tipos:

  • float: utilice este valor para devolver las incrustaciones flotantes predeterminadas.

  • int8: utilice este valor para devolver las incrustaciones int8 firmadas.

  • uint8: utilice este valor para devolver las incrustaciones int8 no firmadas.

  • binary: utilice este valor para devolver las incrustaciones binarias firmadas.

  • ubinary: utilice este valor para devolver las incrustaciones binarias no firmadas.

Para obtener más información, consulte https://docs.cohere.com/reference/incrustar en el Cohere .

Response

La respuesta body de una llamada a InvokeModel es la siguiente:

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

La respuesta body tiene los siguientes campos posibles:

• id: identificador de la respuesta.

• response_type: es el tipo de respuesta. Este valor siempre es embeddings_floats.

• incrustaciones: una matriz de incrustaciones, en la que cada incrustación es una matriz de elementos flotantes con 1024 elementos. La longitud de la matriz embeddings será la misma que la longitud de la matriz texts original.

• textos: una matriz que contiene las entradas de texto para las que se devolvieron las incrustaciones.

Para obtener más información, consulte https://docs.cohere.com/reference/incrustar.

Ejemplo de código

En este ejemplo se muestra cómo llamar al Cohere Embed Englishmodelo.

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