CohereCommandmodèles

Vous envoyez des demandes d'inférence à un Cohere Command modèle avec InvokeModelou InvokeModelWithResponseStream(streaming). Vous avez besoin de l’ID du modèle que vous voulez utiliser. Pour obtenir l'ID du modèle, voirModèle Amazon Bedrock IDs.

Demande et réponse

Request

Les Cohere Command modèles possèdent les paramètres d'inférence suivants.

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

Les paramètres suivants sont obligatoires.

• prompt — (Obligatoire) Le texte d'entrée qui sert de point de départ pour générer la réponse.

  Vous trouverez ci-dessous le texte par appel et les limites de caractères.

Les paramètres suivants sont facultatifs.

• return_likely — Spécifiez comment et si les probabilités symboliques sont renvoyées avec la réponse. Vous pouvez spécifier les options suivantes :

  • GENERATION : renvoie uniquement les probabilités pour les jetons générés.

  • ALL : renvoie les probabilités pour tous les jetons.

  • NONE : (par défaut) ne renvoie aucune probabilité.

• stream — (Obligatoire pour prendre en charge le streaming) Spécifiez true le renvoi de la réponse piece-by-piece en temps réel et false le renvoi de la réponse complète une fois le processus terminé.

• logit_bias — Empêche le modèle de générer des jetons indésirables ou incite le modèle à inclure les jetons souhaités. Le format est {token_id: bias} où le « bias » est un flottant compris entre -10 et 10. Les jetons peuvent être obtenus à partir de texte à l'aide de n'importe quel service de tokenisation, tel que le point Cohere de terminaison Tokenize. Pour plus d'informations, consultez Coherela documentation.

  Par défaut	Minimum	Maximum
  N/A	-10 (pour un biais de jeton)	10 (pour un biais de jeton)

• num_generations — Le nombre maximum de générations que le modèle doit renvoyer.

  Par défaut	Minimum	Maximum
  1	1	5

• tronquer — Spécifie la manière dont il API gère les entrées supérieures à la longueur maximale du jeton. Utilisez l'une des options suivantes :

  • NONE : 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 : (par défaut) 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.

• température — Utilisez une valeur inférieure pour réduire le caractère aléatoire de la réponse.

  Par défaut	Minimum	Maximum
  0.9	0	5

• p — Top P. Utilisez une valeur inférieure pour ignorer les options les moins probables. Réglez cette option sur 0 ou 1,0 pour la désactiver. Si p et k sont activés, p agit après k.

  Par défaut	Minimum	Maximum
  0.75	0	1

• k — Top K. Spécifiez le nombre de choix de jetons que le modèle utilise pour générer le jeton suivant. Si p et k sont activés, p agit après k.

  Par défaut	Minimum	Maximum
  0	0	500

• max_tokens — Spécifiez le nombre maximum de jetons à utiliser dans la réponse générée.

  Par défaut	Minimum	Maximum
  20	1	4096

• stop_sequences — Configurez jusqu'à quatre séquences reconnues par le modèle. Après une séquence d'arrêt, le modèle cesse de générer d'autres jetons. Le texte renvoyé ne contient pas la séquence d'arrêt.

Response

La réponse peut inclure les champs suivants :

{
    "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 : liste des résultats générés ainsi que les probabilités que les jetons soient demandés. (Toujours renvoyé.) Chaque objet de génération dans la liste contient les champs suivants.

  • id : identifiant pour la génération. (Toujours renvoyé.)

  • likelihood : probabilité de la sortie. La valeur est la moyenne des probabilités des jetons dans token_likelihoods. Renvoyé si vous spécifiez le paramètre d’entrée return_likelihoods.

  • token_likelihoods : tableau de probabilités par jeton. Renvoyé si vous spécifiez le paramètre d’entrée return_likelihoods.

  • finish_reason— La raison pour laquelle le modèle a fini de générer des jetons. COMPLETE- le modèle a renvoyé une réponse complète. MAX_TOKENS— la réponse a été interrompue car le modèle a atteint le nombre maximum de jetons par rapport à la longueur de son contexte. ERROR — une erreur s'est produite lors de la génération de la réponse. ERROR_TOXIC— le modèle a généré une réponse jugée toxique. finish_reasonn'est renvoyé que lorsque is_finished =true. (Pas toujours renvoyé.)

  • is_finished : champ booléen utilisé uniquement lorsque stream correspond à true, indiquant si des jetons supplémentaires seront générés dans le cadre de la réponse de streaming. (Pas toujours renvoyé)

  • text : texte généré.

  • index : dans une réponse de streaming, utilisez ce paramètre pour déterminer à quelle génération appartient un jeton donné. Lorsqu’une seule réponse est diffusée, tous les jetons appartiennent à la même génération, et l’index n’est pas renvoyé. index n’est donc renvoyé que dans une demande de streaming dont la valeur num_generations est supérieure à un.

• prompt— L'invite de la demande d'entrée (toujours renvoyée).

• id : identifiant de la demande (toujours renvoyé).

Pour plus d'informations, consultez la section Générer dans les Cohere documentations.

Exemple de code

Cet exemple montre comment appeler le CohereCommandmodèle.

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