Cohere Embed modelli

Fai richieste di inferenza a un Embed model con InvokeModelÈ necessario l'ID del modello per il modello che si desidera utilizzare. Per ottenere l'ID del modello, vediModello Amazon Bedrock IDs.

Nota

Amazon Bedrock non supporta le risposte in streaming da Cohere Embed modelli.

Richiesta e risposta

Request

Il Cohere Embed i modelli hanno i seguenti parametri di inferenza.

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

I seguenti sono parametri obbligatori.

• text — Una serie di stringhe da incorporare nel modello. Per prestazioni ottimali, consigliamo di ridurre la lunghezza di ogni testo a meno di 512 token. 1 token corrisponde a circa 4 caratteri.

  Di seguito sono riportati i limiti di testo per chiamata e di caratteri.

  Testi per chiamata

  Minimo	Massimo
  0 testi	96 testi

  Personaggi

  Minimo	Massimo
  0 caratteri	2048 caratteri

• input_type — Aggiunge token speciali per differenziare ogni tipo l'uno dall'altro. Non conviene mischiare tipi diversi, tranne quelli per la ricerca e il recupero. In questo caso, incorpora il corpus con il tipo search_document e le query incorporate con il tipo search_query.

  • search_document: nei casi d'uso legati alla ricerca, utilizza search_document per codificare i documenti per gli incorporamenti archiviati in un database vettoriale.

  • search_query: utilizza search_query per interrogare il database vettoriale al fine di trovare i documenti pertinenti.

  • classification: utilizza classification quando gli incorporamenti sono usati come input per un classificatore di testo.

  • clustering: utilizza clustering per raggruppare gli incorporamenti.

I seguenti sono parametri opzionali:

• truncate: specifica in che modo l'utente API gestisce gli input più lunghi della lunghezza massima del token. Utilizzare una delle seguenti operazioni:

  • NONE: (impostazione predefinita) restituisce un errore quando l'input supera la lunghezza massima del token di input.

  • START— Scarta l'inizio dell'input.

  • END: elimina la fine dell'input.

  Se specifichi START oEND, il modello elimina l'input finché quello rimanente non raggiunge esattamente la lunghezza massima del token di input per il modello.

• embedding_types: specifica i tipi di incorporamenti che si desidera vengano restituiti. Facoltativo e predefinito èNone, che restituisce il tipo di risposta. Embed Floats Può essere uno o più dei seguenti tipi:

  • float— Utilizzate questo valore per restituire gli incorporamenti float predefiniti.

  • int8— Utilizzate questo valore per restituire incorporamenti int8 firmati.

  • uint8— Utilizzate questo valore per restituire incorporamenti int8 non firmati.

  • binary— Utilizzate questo valore per restituire incorporamenti binari firmati.

  • ubinary— Utilizzate questo valore per restituire incorporamenti binari non firmati.

Per ulteriori informazioni, vedere https://docs.cohere.com/reference/incorporare in Cohere documentazione.

Response

Di seguito è riportata la risposta body da una chiamata InvokeModel.

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

La risposta body ha i seguenti campi possibili:

• id: un identificatore per la risposta.

• response_type — Il tipo di risposta. Questo valore è sempre embeddings_floats.

• embeddings: un array di incorporamenti, ognuno dei quali è un array di numeri a virgola mobile con 1024 elementi. La lunghezza dell'array embeddings sarà uguale alla lunghezza dell'array texts originale.

• texts: un array contenente le voci di testo per le quali sono stati restituiti incorporamenti.

Per ulteriori informazioni, consulta embed. https://docs.cohere.com/reference/

esempio di codice

Questo esempio mostra come chiamare il Cohere Embed Englishmodello.

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