CohereCommandmodelos

Você faz solicitações de inferência para um Cohere Command modelo com InvokeModelou InvokeModelWithResponseStream(streaming). É necessário o ID do modelo que deseja usar. Para obter o ID do modelo, consulteIDs de modelo Amazon Bedrock.

Solicitação e reposta

Request

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

{
    "prompt": string,
    "temperature": float,
    "p": float,
    "k": float,
    "max_tokens": int,
    "stop_sequences": [string],
    "return_likelihoods": "GENERATION|ALL|NONE",
    "stream": boolean,
    "num_generations": int,
    "logit_bias": {token_id: bias},
    "truncate": "NONE|START|END"
}

Veja a seguir os parâmetros necessários.

• prompt — (Obrigatório) O texto de entrada que serve como ponto de partida para gerar a resposta.

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

Veja a seguir os parâmetros opcionais.

• return_likhoods — Especifique como e se as probabilidades do token são retornadas com a resposta. Você pode especificar as seguintes opções:

  • GENERATION: só retorna as probabilidades dos tokens gerados.

  • ALL: retorna as probabilidades de todos os tokens.

  • NONE (padrão): não retorna nenhuma probabilidade.

• stream — (Obrigatório para suportar streaming) Especifique true para retornar a resposta piece-by-piece em tempo real e false retornar a resposta completa após a conclusão do processo.

• logit_bias — Impede que o modelo gere tokens indesejados ou incentiva o modelo a incluir os tokens desejados. O formato é {token_id: bias}, em que bias é um float entre -10 e 10. Os tokens podem ser obtidos do texto usando qualquer serviço de tokenização, como o endpoint Cohere Tokenize. Para obter mais informações, consulte a Coheredocumentação.

  Padrão	Mínimo	Máximo
  N/D	-10 (para um viés de token)	10 (para um viés de token)

• num_generations — O número máximo de gerações que o modelo deve retornar.

  Padrão	Mínimo	Máximo
  1	1	5

• truncate — Especifica como a API processa entradas maiores do que o tamanho máximo do token. Use uma das seguintes opções:

  • NONE: retorna um erro quando a entrada excede o tamanho máximo de token de entrada.

  • START: descarta o início da entrada.

  • END (padrão): 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 de token de entrada para o modelo.

• temperatura — Use um valor menor para diminuir a aleatoriedade na resposta.

  Padrão	Mínimo	Máximo
  0.9	0	5

• p — Top P. Use um valor menor para ignorar as opções menos prováveis. Defina como 0 ou 1,0 para desabilitar. Se p e k estiverem habilitados, p agirá depois de k.

  Padrão	Mínimo	Máximo
  0.75	0	1

• k — Top K. Especifique o número de opções de token que o modelo usa para gerar o próximo token. Se p e k estiverem habilitados, p agirá depois de k.

  Padrão	Mínimo	Máximo
  0	0	500

• max_tokens — Especifique o número máximo de tokens a serem usados na resposta gerada.

  Padrão	Mínimo	Máximo
  20	1	4096

• stop_sequences — Configure até quatro sequências que o modelo reconheça. Depois de uma sequência de interrupção, o modelo para de gerar tokens. O texto retornado não contém a sequência de interrupção.

Response

A resposta tem os seguintes campos possíveis:

{
    "generations": [
        {
            "finish_reason": "COMPLETE | MAX_TOKENS | ERROR | ERROR_TOXIC",
            "id": string,
            "text": string,
            "likelihood" : float,
            "token_likelihoods" : [{"token" : float}],
            "is_finished" : true | false,
            "index" : integer
           
        }
    ],
    "id": string,
    "prompt": string
}

• generations: uma lista dos resultados gerados com as probabilidades dos tokens solicitados. Sempre é retornado. Cada objeto de geração na lista contém os campos a seguir.

  • id: um identificador para a geração. Sempre é retornado.

  • likelihood: a probabilidade da saída. O valor é a média das probabilidades do token em token_likelihoods. Será retornado se você especificar o parâmetro de entrada return_likelihoods.

  • token_likelihoods: uma matriz de probabilidades por token. Será retornado se você especificar o parâmetro de entrada return_likelihoods.

  • finish_reason— O motivo pelo qual o modelo terminou de gerar tokens. COMPLETE- o modelo enviou de volta uma resposta finalizada. MAX_TOKENS— a resposta foi cortada porque o modelo atingiu o número máximo de tokens para o tamanho do contexto. ERROR — algo deu errado ao gerar a resposta. ERROR_TOXIC— o modelo gerou uma resposta que foi considerada tóxica. finish_reasoné retornado somente quando is_finished =true. Nem sempre é retornado.

  • is_finished: um campo booleano usado somente quando stream é true, indicando se há ou não tokens adicionais que serão gerados como parte da resposta de streaming. Nem sempre é retornado.

  • text: o texto gerado.

  • index: em uma resposta de streaming, use para determinar a qual geração determinado token pertence. Quando apenas uma resposta é transmitida, todos os tokens pertencem à mesma geração e o índice não é retornado. Portanto, index só é retornado em uma solicitação de streaming com um valor de num_generations maior que um.

• prompt— O prompt da solicitação de entrada (sempre retornado).

• id: um identificador para a solicitação (sempre é retornado).

Para obter mais informações, consulte https://docs.cohere.com/reference/generate nas Cohere documentações.

Exemplo de código

Este exemplo mostra como chamar o CohereCommandmodelo.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text using a Cohere model.
"""
import json
import logging
import boto3


from botocore.exceptions import ClientError

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_text(model_id, body):
    """
    Generate text using a Cohere 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 with Cohere model %s", model_id)

    accept = 'application/json'
    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 example.
    """

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    model_id = 'cohere.command-text-v14'
    prompt = """Summarize this dialogue: 
"Customer: Please connect me with a support agent.
AI: Hi there, how can I assist you today?
Customer: I forgot my password and lost access to the email affiliated to my account. Can you please help me?
AI: Yes of course. First I'll need to confirm your identity and then I can connect you with one of our support agents.
"""
    try:
        body = json.dumps({
            "prompt": prompt,
            "max_tokens": 200,
            "temperature": 0.6,
            "p": 1,
            "k": 0,
            "num_generations": 2,
            "return_likelihoods": "GENERATION"
        })
        response = generate_text(model_id=model_id,
                                 body=body)

        response_body = json.loads(response.get('body').read())
        generations = response_body.get('generations')

        for index, generation in enumerate(generations):

            print(f"Generation {index + 1}\n------------")
            print(f"Text:\n {generation['text']}\n")
            if 'likelihood' in generation:
                print(f"Likelihood:\n {generation['likelihood']}\n")
            
            print(f"Reason: {generation['finish_reason']}\n\n")

    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 with Cohere model {model_id}.")


if __name__ == "__main__":
    main()