Cohere Command modelos

Realiza solicitudes de inferencia a un Cohere Command modela con InvokeModelo InvokeModelWithResponseStream(streaming). Necesitará el ID de modelo del modelo que desee utilizar. Para obtener el identificador del modelo, consulteModelo Amazon Bedrock IDs.

Temas

Solicitud y respuesta
Ejemplo de código

Solicitud y respuesta

Request

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


{
    "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"
}

Los siguientes parámetros son obligatorios.

prompt: (obligatorio) el texto de entrada que sirve como punto de partida para generar la respuesta.

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

Los siguientes son parámetros opcionales.

return_likelihoods: especifica cómo y si se devuelven las probabilidades simbólicas junto con la respuesta. Puede especificar las opciones siguientes:
- GENERATION: solo devuelve las probabilidades de los tokens generados.
- ALL: devuelve las probabilidades de todos los tokens.
- NONE: (predeterminado) no devuelvas ninguna probabilidad.
stream: (obligatorio para admitir la transmisión) Especifique si desea true devolver la respuesta piece-by-piece en tiempo real y devolver la respuesta completa una vez false finalizado el proceso.

logit_bias: evita que el modelo genere fichas no deseadas o incentiva al modelo a incluir las fichas deseadas. El formato es {token_id: bias} en el que el sesgo es un número flotante entre -10 y 10. Los tokens se pueden obtener a partir del texto mediante cualquier servicio de tokenización, como Coherees el punto final de Tokenize. Para obtener más información, consulte Cohere documentación.

Predeterminado	Mínimo	Máximo
N/A	-10 (para un sesgo de token)	10 (para un sesgo de token)

num_generations: el número máximo de generaciones que debe devolver el modelo.

Predeterminado	Mínimo	Máximo
1	1	5

truncar: especifica cómo API gestiona las entradas con una longitud superior a la longitud máxima del token. Utilice una de las siguientes:
- NONE: devuelve un error cuando la entrada supera la longitud máxima del token de entrada.
- START: descarta el inicio de la entrada.
- END: (predeterminado) 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.

temperatura: utilice un valor inferior para reducir la aleatoriedad de la respuesta.

Predeterminado	Mínimo	Máximo
0.9	0	5

p — Top P. Usa un valor más bajo para ignorar las opciones menos probables. Configúrelo en 0 o 1,0 para deshabilitarlo. Si ambos p y k están activados, p actúa después k.

Predeterminado	Mínimo	Máximo
0.75	0	1

k — Top K. Especifique el número de opciones de token que el modelo utilizará para generar el siguiente token. Si ambos p y k están activados, p actúa después k.

Predeterminado	Mínimo	Máximo
0	0	500

max_tokens: especifique la cantidad máxima de tokens que se utilizarán en la respuesta generada.

Predeterminado	Mínimo	Máximo
20	1	4096

stop_sequences: configure hasta cuatro secuencias que el modelo reconozca. Tras una secuencia de detención, el modelo deja de generar más tokens. El texto devuelto no contiene la secuencia de detención.

Response

La respuesta tiene los siguientes campos posibles:


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

generations: una lista de los resultados generados junto con las probabilidades de que se soliciten los tokens. (Siempre se devuelve). Cada objeto de generación de la lista incluye los siguientes campos:
- id: un identificador para la generación. (Siempre se devuelve).
- likelihood: la probabilidad de la salida. El valor es el promedio de las probabilidades del token en token_likelihoods. Se devuelve si se especifica el parámetro de entrada return_likelihoods.
- token_likelihoods: un conjunto de probabilidades por token. Se devuelve si se especifica el parámetro de entrada return_likelihoods.
- finish_reason— La razón por la que el modelo terminó de generar fichas. COMPLETE- el modelo envió una respuesta finalizada. MAX_TOKENS— la respuesta se interrumpió porque el modelo alcanzó el número máximo de fichas para su longitud de contexto. ERROR— algo salió mal al generar la respuesta. ERROR_TOXIC— el modelo generó una respuesta que se consideró tóxica. finish_reasonse devuelve solo cuando is_finished =true. (No siempre se devuelve).
- is_finished: un campo booleano que se usa solo cuando stream es true, lo que indica si hay o no tokens adicionales que se generarán como parte de la respuesta de la transmisión. (No siempre se devuelve).
- text: el texto generado.
- index: en una respuesta de transmisión, se usa para determinar a qué generación pertenece un token determinado. Cuando solo se transmite una respuesta, todos los tokens pertenecen a la misma generación y no se devuelve el índice. Por lo tanto, index solo se devuelve en una solicitud de transmisión con un valor para num_generations superior a uno.
prompt— El mensaje de la solicitud de entrada (siempre se devuelve).
id: un identificador de la solicitud (siempre devuelto).

Para obtener más información, consulte Generar en el Cohere documentaciones.

Ejemplo de código

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


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

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Cohere modelos

Cohere Embed modelos