Cohere Command Modelle

Sie stellen Rückschlussanfragen an einen Cohere Command Modell mit InvokeModeloder InvokeModelWithResponseStream(Streaming). Sie benötigen die Modell-ID für das Modell, das Sie verwenden möchten. Informationen zum Abrufen der Modell-ID finden Sie unterModell Amazon Bedrock IDs.

Anforderung und Antwort

Request

Das Tool Cohere Command Modelle haben die folgenden Inferenzparameter.

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

Die folgenden Parameter sind erforderlich.

• prompt — (Erforderlich) Der Eingabetext, der als Ausgangspunkt für die Generierung der Antwort dient.

  Im Folgenden sind Text pro Aufruf und Zeichenbeschränkungen aufgeführt.

Die folgenden Parameter sind optional.

• return_probability — Geben Sie an, wie und ob die Token-Likelihood zusammen mit der Antwort zurückgegeben werden. Sie können die folgenden Optionen angeben:

  • GENERATION – gibt nur Wahrscheinlichkeiten für generierte Token zurück.

  • ALL – gibt Wahrscheinlichkeiten für alle Token zurück.

  • NONE – (Standard) gibt keine Wahrscheinlichkeiten zurück.

• stream — (Erforderlich für die Unterstützung von Streaming) Geben Sie true an, ob die Antwort piece-by-piece in Echtzeit und die vollständige Antwort false nach Abschluss des Vorgangs zurückgegeben werden soll.

• logit_bias — Verhindert, dass das Modell unerwünschte Token generiert, oder bietet Anreize für das Modell, die gewünschten Token einzubeziehen. Das Format lautet {token_id: bias}, wobei „bias“ eine Gleitkommazahl zwischen -10 und 10 ist. Token können mithilfe eines beliebigen Tokenisierungsdienstes aus Text abgerufen werden, z. B. Cohereist der Tokenize-Endpunkt. Weitere Informationen finden Sie unter Cohere Dokumentation.

  Standard	Minimum	Maximum
  N/A	-10 (für einen Token-Bias)	10 (für einen Token-Bias)

• num_generations — Die maximale Anzahl von Generationen, die das Modell zurückgeben soll.

  Standard	Minimum	Maximum
  1	1	5

• truncate — Gibt an, wie Eingaben API verarbeitet werden, die länger als die maximale Token-Länge sind. Nutzen Sie einen der Folgenden:

  • NONE – gibt einen Fehler zurück, wenn die Eingabe die maximale Länge des Eingabe-Tokens überschreitet.

  • START – verwirft den Anfang der Eingabe.

  • END – (Standard) verwirft das Ende der Eingabe.

  Wenn Sie START oder END angeben, verwirft das Modell die Eingabe, bis die verbleibende Eingabe genau der maximalen Länge des Eingabe-Tokens für das Modell entspricht.

• Temperatur — Verwenden Sie einen niedrigeren Wert, um die Zufälligkeit der Antwortvariablen zu verringern.

  Standard	Minimum	Maximum
  0.9	0	5

• p — Top P. Verwenden Sie einen niedrigeren Wert, um weniger wahrscheinliche Optionen zu ignorieren. Legen Sie den Wert auf 0 oder 1,0 fest, um den Parameter zu deaktivieren. Wenn p sowohl als auch k aktiviert sind, wird p nach k aktiv.

  Standard	Minimum	Maximum
  0.75	0	1

• k — Top K. Geben Sie die Anzahl der Token-Optionen an, die das Modell zur Generierung des nächsten Tokens verwendet. Wenn p sowohl als auch k aktiviert sind, wird p nach k aktiv.

  Standard	Minimum	Maximum
  0	0	500

• max_tokens — Geben Sie die maximale Anzahl von Tokens an, die in der generierten Antwort verwendet werden sollen.

  Standard	Minimum	Maximum
  20	1	4096

• stop_sequences — Konfigurieren Sie bis zu vier Sequenzen, die das Modell erkennt. Nach einer Stoppsequenz stoppt das Modell die Generierung weiterer Token. Der zurückgegebene Text enthält keine Stoppsequenz.

Response

Die Antwort enthält folgende mögliche Felder:

{
    "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 – eine Liste der generierten Ergebnisse zusammen mit den Wahrscheinlichkeiten für die angeforderten Token. (Immer zurückgegeben) Jedes Generierungsobjekt in der Liste umfasst die folgenden Felder.

  • id – eine Kennung für die Generation. (Immer zurückgegeben)

  • likelihood – die Wahrscheinlichkeit der Ausgabe. Der Wert ist der Durchschnitt der Token-Wahrscheinlichkeiten in token_likelihoods. Wird zurückgegeben, wenn Sie den Eingabeparameter return_likelihoods angeben.

  • token_likelihoods – ein Array von Wahrscheinlichkeiten pro Token. Wird zurückgegeben, wenn Sie den Eingabeparameter return_likelihoods angeben.

  • finish_reason— Der Grund, warum das Modell die Token-Generierung abgeschlossen hat. COMPLETE- Das Modell hat eine fertige Antwort zurückgeschickt. MAX_TOKENS— Die Antwort wurde unterbrochen, weil das Modell die maximale Anzahl an Tokens für seine Kontextlänge erreicht hat. ERROR — bei der Generierung der Antwort ist etwas schief gelaufen. ERROR_TOXIC— das Modell generierte eine Antwort, die als toxisch eingestuft wurde. finish_reasonwird nur zurückgegeben, wenn is_finished =true. (Nicht immer zurückgegeben)

  • is_finished – ein boolesches Feld, das nur verwendet wird, wenn stream gleich true ist. Es gibt an, ob zusätzliche Token im Rahmen der Streaming-Antwort generiert werden oder nicht. (Nicht immer zurückgegeben)

  • text – der generierte Text.

  • index – wird in einer Streaming-Antwort verwendet, um festzustellen, zu welcher Generation ein bestimmtes Token gehört. Wenn nur eine Antwort gestreamt wird, gehören alle Token derselben Generation an und der Index wird nicht zurückgegeben. index wird daher nur in einer Streaming-Anforderung zurückgegeben, deren Wert für num_generations größer als eins ist.

• prompt— Die Aufforderung aus der Eingabeanforderung (immer zurückgegeben).

• id – eine Kennung für die Anforderung (immer zurückgegeben).

Weitere Informationen finden Sie unter Generieren in der Cohere Dokumentationen.

Codebeispiel

Dieses Beispiel zeigt, wie man den aufruft Cohere CommandModell.

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