CohereEmbedmodelos

Você faz solicitações de inferência para um Embed modelo com InvokeModelVocê precisa do ID do modelo que deseja usar. Para obter o ID do modelo, consulteIDs de modelo Amazon Bedrock.

nota

O Amazon Bedrock não suporta respostas de streaming de Cohere Embed modelos.

Solicitação e reposta

Request

Os Cohere Embed modelos têm os seguintes parâmetros de inferência.

{
    "texts":[string],
    "input_type": "search_document|search_query|classification|clustering",
    "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 um desempenho ideal, recomendamos reduzir o tamanho de cada texto para menos de 512 tokens. 1 token tem cerca de 4 caracteres.

  A seguir estão os limites de texto por chamada e caracteres.

  Textos por chamada

  Mínimo	Máximo
  0 textos	96 textos

  Personagens

  Mínimo	Máximo
  0 caracteres	2048 caracteres

• input_type — Anexa tokens especiais para diferenciar cada tipo um do outro. Você não deve misturar tipos diferentes, 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.

A seguir estão os parâmetros opcionais:

• truncate — Especifica como a API processa entradas maiores do 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_types — Especifica os tipos de incorporações que você deseja que sejam retornadas. Opcional e o padrão éNone, que retorna o tipo de Embed Floats resposta. Pode ser um ou mais dos seguintes tipos:

  • float— Use esse valor para retornar as incorporações flutuantes padrão.

  • int8— Use esse valor para retornar incorporações int8 assinadas.

  • uint8— Use esse valor para retornar incorporações int8 não assinadas.

  • binary— Use esse valor para retornar incorporações binárias assinadas.

  • ubinary— Use esse valor para retornar incorporações binárias não assinadas.

Para obter mais informações, consulte https://docs.cohere.com/reference/embed na Cohere documentação.

Response

A resposta body de uma chamada para InvokeModel é a seguinte:

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

A resposta do body tem os seguintes campos:

• id: um identificador para a resposta.

• response_type — O tipo de resposta. Esse valor é sempre embeddings_floats.

• incorporações: uma matriz de incorporações, em que cada incorporação é uma matriz de flutuadores com 1024 elementos. O comprimento da matriz embeddings será igual ao comprimento da matriz texts original.

• textos: uma matriz contendo as entradas de texto para as quais as incorporações foram retornadas.

Para obter mais informações, consulte https://docs.cohere.com/reference/embed.

Exemplo de código

Este exemplo mostra como chamar o CohereEmbed 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()