CohereEmbedModelle

Sie stellen Inferenzanfragen an ein Embed Modell mit InvokeModelSie benötigen die Modell-ID für das Modell, das Sie verwenden möchten. Informationen zum Abrufen der Modell-ID finden Sie unterModell-IDs von Amazon Bedrock.

Anmerkung

Amazon Bedrock unterstützt keine Streaming-Antworten von Cohere Embed Modellen.

Anforderung und Antwort

Request

Die Cohere Embed Modelle haben die folgenden Inferenzparameter.

{
    "texts":[string],
    "input_type": "search_document|search_query|classification|clustering",
    "truncate": "NONE|START|END",
    "embedding_types": embedding_types
}

Die folgenden Parameter sind erforderlich.

• Texte — Eine Reihe von Zeichenketten, die das Modell einbetten soll. Für eine optimale Leistung empfehlen wir, die Länge jedes Textes auf weniger als 512 Token zu reduzieren. Ein Token entspricht etwa 4 Zeichen.

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

  Texte pro Anruf

  Minimum	Maximum
  0 Texte	96 Texte

  Charaktere

  Minimum	Maximum
  0 Zeichen	2048 Zeichen

• input_type — Stellt spezielle Tokens voran, um die einzelnen Typen voneinander zu unterscheiden. Sie sollten verschiedene Typen nicht miteinander vermengen, außer wenn Sie Typen zum Suchen und Abrufen mischen. In diesem Fall betten Sie Ihren Korpus mit dem Typ search_document und eingebettete Abfragen mit dem Typ search_query ein.

  • search_document – Verwenden Sie search_document bei Suchen, wenn Sie Dokumente für Einbettungen kodieren, die Sie in einer Vektordatenbank speichern.

  • search_query – Verwenden Sie search_query, wenn Sie Ihre Vektordatenbank abfragen, um relevante Dokumente zu finden.

  • classification – Verwenden Sie classification, wenn Einbettungen als Eingabe für einen Textklassifizier verwendet werden.

  • clustering – Verwenden Sie clustering, um die Einbettungen in Cluster zu gruppieren.

Die folgenden Parameter sind optional:

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

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

  • START— Verwirft den Anfang der Eingabe.

  • END – 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.

• embedding_types — Gibt die Arten von Einbettungen an, die zurückgegeben werden sollen. Optional und die Standardeinstellung istNone, was den Antworttyp zurückgibt. Embed Floats Es kann sich um einen oder mehrere der folgenden Typen handeln:

  • float— Verwenden Sie diesen Wert, um die standardmäßigen Float-Einbettungen zurückzugeben.

  • int8— Verwenden Sie diesen Wert, um signierte int8-Einbettungen zurückzugeben.

  • uint8— Verwenden Sie diesen Wert, um vorzeichenlose int8-Einbettungen zurückzugeben.

  • binary— Verwenden Sie diesen Wert, um binäre Einbettungen mit Vorzeichen zurückzugeben.

  • ubinary— Verwenden Sie diesen Wert, um binäre Einbettungen ohne Vorzeichen zurückzugeben.

Weitere Informationen finden Sie in der Dokumentation unter https://docs.cohere.com/reference/embed. Cohere

Response

Die body-Antwort eines Aufrufs von InvokeModel lautet wie folgt:

{
    "embeddings": [
        [ <array of 1024 floats> ]
    ],
    "id": string,
    "response_type" : "embeddings_floats,
    "texts": [string]
}
                    
                

Die body-Antwort enthält folgende mögliche Felder:

• id – Eine Kennung für die Antwort.

• response_type — Der Antworttyp. Dieser Wert ist immer embeddings_floats.

• embeddings – ein Array von Einbettungen, wobei jede Einbettung ein Array von Gleitkommazahlen mit 1024 Elementen ist. Die Länge des embeddings-Arrays entspricht der Länge des ursprünglichen texts-Arrays.

• texts – ein Array, das die Texteinträge enthält, für die Einbettungen zurückgegeben wurden.

Weitere Informationen finden Sie unter https://docs.cohere.com/reference/embed.

Codebeispiel

Dieses Beispiel zeigt, wie das Modell aufgerufen wird. CohereEmbed English

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


from botocore.exceptions import ClientError

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


def generate_text_embeddings(model_id, body):
    """
    Generate text embedding by using the Cohere Embed 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 emdeddings with the Cohere Embed model %s", model_id)

    accept = '*/*'
    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 Embed example.
    """

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

    model_id = 'cohere.embed-english-v3'
    text1 = "hello world"
    text2 = "this is a test"
    input_type = "search_document"
    embedding_types = ["int8", "float"]

    try:

        body = json.dumps({
            "texts": [
                text1,
                text2],
            "input_type": input_type,
            "embedding_types": embedding_types}
        )
        response = generate_text_embeddings(model_id=model_id,
                                            body=body)

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

        print(f"ID: {response_body.get('id')}")
        print(f"Response type: {response_body.get('response_type')}")

        print("Embeddings")
        for i, embedding in enumerate(response_body.get('embeddings')):
            print(f"\tEmbedding {i}")
            print(*embedding)

        print("Texts")
        for i, text in enumerate(response_body.get('texts')):
            print(f"\tText {i}: {text}")

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


if __name__ == "__main__":
    main()