CohereCommandmodel

Anda membuat permintaan inferensi ke Cohere Command model dengan InvokeModelatau InvokeModelWithResponseStream(streaming). Anda memerlukan ID model untuk model yang ingin Anda gunakan. Untuk mendapatkan ID model, lihatID model Amazon Bedrock.

Permintaan dan Tanggapan

Request

CohereCommandModel memiliki parameter inferensi berikut.

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

Berikut ini adalah parameter yang diperlukan.

• prompt — (Wajib) Teks masukan yang berfungsi sebagai titik awal untuk menghasilkan respons.

  Berikut ini adalah teks per panggilan dan batas karakter.

Berikut ini adalah parameter opsional.

• return_likelihoods — Tentukan bagaimana dan apakah kemungkinan token dikembalikan dengan respons. Anda dapat menentukan opsi berikut.

  • GENERATION— Hanya mengembalikan kemungkinan untuk token yang dihasilkan.

  • ALL— Kembalikan kemungkinan untuk semua token.

  • NONE— (Default) Jangan mengembalikan kemungkinan apa pun.

• stream — (Diperlukan untuk mendukung streaming) Tentukan true untuk mengembalikan respons piece-by-piece secara real-time dan false mengembalikan respons lengkap setelah proses selesai.

• logit_bias — Mencegah model menghasilkan token yang tidak diinginkan atau memberi insentif kepada model untuk menyertakan token yang diinginkan. Formatnya adalah {token_id: bias} di mana bias adalah float antara -10 dan 10. Token dapat diperoleh dari teks menggunakan layanan tokenisasi apa pun, seperti titik akhir Cohere Tokenize. Untuk informasi lebih lanjut, lihat Coheredokumentasi.

  Default	Minimum	Maksimum
  N/A	-10 (untuk bias token)	10 (untuk bias token)

• num_generation — Jumlah maksimum generasi yang harus dikembalikan model.

  Default	Minimum	Maksimum
  1	1	5

• truncate — Menentukan bagaimana API menangani input lebih lama dari panjang token maksimum. Gunakan salah satu langkah berikut:

  • NONE— Mengembalikan kesalahan ketika input melebihi panjang token masukan maksimum.

  • START— Buang awal input.

  • END— (Default) Buang akhir input.

  Jika Anda menentukan START atauEND, model membuang input hingga input yang tersisa persis dengan panjang token input maksimum untuk model.

• suhu — Gunakan nilai yang lebih rendah untuk mengurangi keacakan dalam respons.

  Default	Minimum	Maksimum
  0,9	0	5

• p — Top P. Gunakan nilai yang lebih rendah untuk mengabaikan opsi yang kurang mungkin. Setel ke 0 atau 1.0 untuk menonaktifkan. Jika keduanya p dan k diaktifkan, p bertindak setelahnyak.

  Default	Minimum	Maksimum
  0,75	0	1

• k — Top K. Tentukan jumlah pilihan token yang digunakan model untuk menghasilkan token berikutnya. Jika keduanya p dan k diaktifkan, p bertindak setelahnyak.

  Default	Minimum	Maksimum
  0	0	500

• max_tokens — Tentukan jumlah maksimum token yang akan digunakan dalam respons yang dihasilkan.

  Default	Minimum	Maksimum
  20	1	4096

• stop_sequences — Konfigurasikan hingga empat urutan yang dikenali model. Setelah urutan berhenti, model berhenti menghasilkan token lebih lanjut. Teks yang dikembalikan tidak berisi urutan berhenti.

Response

Tanggapan memiliki bidang yang mungkin berikut:

{
    "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— Daftar hasil yang dihasilkan bersama dengan kemungkinan token yang diminta. (Selalu kembali). Setiap objek generasi dalam daftar berisi bidang-bidang berikut.

  • id— Pengenal untuk generasi. (Selalu kembali).

  • likelihood— Kemungkinan output. Nilainya adalah rata-rata kemungkinan token di. token_likelihoods Dikembalikan jika Anda menentukan parameter return_likelihoods input.

  • token_likelihoods— Array kemungkinan per token. Dikembalikan jika Anda menentukan parameter return_likelihoods input.

  • finish_reason— Alasan mengapa model selesai menghasilkan token. COMPLETE- model mengirim kembali balasan yang sudah selesai. MAX_TOKENS— jawabannya terputus karena model mencapai jumlah token maksimum untuk panjang konteksnya. ERROR — ada yang tidak beres saat menghasilkan balasan. ERROR_TOXIC— model menghasilkan balasan yang dianggap beracun. finish_reasondikembalikan hanya ketika is_finished =true. (Tidak selalu kembali).

  • is_finished— Bidang boolean hanya digunakan ketika stream adatrue, menandakan apakah ada token tambahan yang akan dihasilkan sebagai bagian dari respons streaming atau tidak. (Tidak selalu kembali)

  • text— Teks yang dihasilkan.

  • index— Dalam respons streaming, gunakan untuk menentukan generasi mana token tertentu dimiliki. Ketika hanya satu respons yang dialirkan, semua token milik generasi yang sama dan indeks tidak dikembalikan. indexoleh karena itu hanya dikembalikan dalam permintaan streaming dengan nilai num_generations yang lebih besar dari satu.

• prompt— Prompt dari permintaan input (selalu dikembalikan).

• id— Pengenal untuk permintaan (selalu dikembalikan).

Untuk informasi lebih lanjut, lihat https://docs.cohere.com/reference/generate dalam Cohere dokumentasi.

Contoh kode

Contoh ini menunjukkan cara memanggil CohereCommandmodel.

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