Texte d'intégration d'Amazon Titan

Titan Embeddings G1 - Textne prend pas en charge l'utilisation de paramètres d'inférence. Les sections suivantes détaillent les formats de demande et de réponse et fournissent un exemple de code.

Demande et réponse

Le corps de la demande est transmis dans le body champ d'une InvokeModeldemande.

V2 Request

Le paramètre InputText est obligatoire. Les paramètres de normalisation et de dimensions sont facultatifs.

• InputText — Entrez le texte à convertir en éléments incorporés.

• normalize : indicateur indiquant s'il faut ou non normaliser les intégrations de sortie. La valeur par défaut est true (vrai).

• dimensions - Le nombre de dimensions que les intégrations de sortie doivent avoir. Les valeurs suivantes sont acceptées : 1024 (par défaut), 512, 256.

{
                        "inputText": string,
                        "dimensions": int,
                        "normalize": boolean
}

V2 Response

Les champs sont décrits ci-dessous.

• incorporation — Tableau qui représente le vecteur d'intégration de l'entrée que vous avez fournie.

• input TextTokenCount — Le nombre de jetons dans l'entrée.

{
    "embedding": [float, float, ...],
    "inputTextTokenCount": int
}

G1 Request

Le seul champ disponible est celui inputText dans lequel vous pouvez inclure du texte à convertir en éléments incorporés.

{
    "inputText": string
}

G1 Response

La body réponse contient les champs suivants.

{
    "embedding": [float, float, ...],
    "inputTextTokenCount": int
}

Les champs sont décrits ci-dessous.

• incorporation — Tableau qui représente le vecteur d'intégration de l'entrée que vous avez fournie.

• TextTokenNombre d'entrées : nombre de jetons dans l'entrée.

Exemple de code

Les exemples suivants montrent comment appeler le modèle Amazon Titan Embeddings pour générer des intégrations. Sélectionnez l'onglet correspondant au modèle que vous utilisez :

Amazon Titan Embeddings G1 – Text

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings with the Amazon Titan Embeddings G1 - Text model (on demand).
"""

import json
import logging
import boto3


from botocore.exceptions import ClientError


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


def generate_embeddings(model_id, body):
    """
    Generate a vector of embeddings for a text input using Amazon Titan Embeddings G1 - Text on demand.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (JSON): The embedding created by the model and the number of input tokens.
    """

    logger.info("Generating embeddings with Amazon Titan Embeddings G1 - Text model %s", model_id)

    bedrock = boto3.client(service_name='bedrock-runtime')

    accept = "application/json"
    content_type = "application/json"

    response = bedrock.invoke_model(
        body=body, modelId=model_id, accept=accept, contentType=content_type
    )

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

    return response_body


def main():
    """
    Entrypoint for Amazon Titan Embeddings G1 - Text example.
    """

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

    model_id = "amazon.titan-embed-text-v1"
    input_text = "What are the different services that you offer?"


    # Create request body.
    body = json.dumps({
        "inputText": input_text,
    })


    try:

        response = generate_embeddings(model_id, body)

        print(f"Generated embeddings: {response['embedding']}")
        print(f"Input Token count:  {response['inputTextTokenCount']}")

    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 embeddings with Amazon Titan Embeddings G1 - Text model {model_id}.")


if __name__ == "__main__":
    main()

Amazon Titan Text Embeddings V2

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings with the Amazon Titan Text Embeddings V2 Model
"""

import json
import logging
import boto3


from botocore.exceptions import ClientError


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


def generate_embeddings(model_id, body):
    """
    Generate a vector of embeddings for a text input using Amazon Titan Text Embeddings G1 on demand.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (JSON): The embedding created by the model and the number of input tokens.
    """

    logger.info("Generating embeddings with Amazon Titan Text Embeddings V2 model %s", model_id)

    bedrock = boto3.client(service_name='bedrock-runtime')

    accept = "application/json"
    content_type = "application/json"

    response = bedrock.invoke_model(
        body=body, modelId=model_id, accept=accept, contentType=content_type
    )

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

    return response_body


def main():
    """
    Entrypoint for Amazon Titan Embeddings V2 - Text example.
    """

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

    model_id = "amazon.titan-embed-text-v2:0"
    input_text = "What are the different services that you offer?"


    # Create request body.
    body = json.dumps({
        "inputText": input_text,
        "dimensions": 512,
        "normalize": True
    })


    try:

        response = generate_embeddings(model_id, body)

        print(f"Generated embeddings: {response['embedding']}")
        print(f"Input Token count:  {response['inputTextTokenCount']}")

    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 embeddings with Amazon Titan Text Embeddings V2 model {model_id}.")


if __name__ == "__main__":
    main()
        </programlisting>
        
        <para><emphasis role="bold">Configure your accuracy-cost tradeoff as you go</emphasis></para>
        <para>While normalization is available via API customers can also reduce the embedding dimension after 
            generating the embeddings allowing them to tradeoff between accuracy and cost as their need evolve. 
            This empower customers to generate 1024-dim index embeddings, store them in low-cost storage options 
            such as S3 and load their 1024, 512 or 256 dimension version in their favorite vector DB as they go. </para>
        <para>To reduce a given embedding from 1024 to 256 dimensions you can use the following example logic:</para>
        <programlisting language="json">import numpy as np
from numpy import linalg

def normalize_embedding(embedding: np.Array):
   '''
   Args:
       embedding: Unnormlized 1D/2D numpy array
              - 1D: (emb_dim)
             - 2D: (batch_size, emb_dim)
   Return:
       np.array: Normalized 1D/2D numpy array 
   '''
   return embedding/linalg.norm(embedding, dim=-1, keep_dim=True)
   
def reduce_emb_dim(embedding: np.Array, target_dim:int, normalize:bool=True) -> np.Array:
   '''
   Args:
       embedding: Unnormlized 1D/2D numpy array. Expected shape:
          - 1D: (emb_dim)
          - 2D: (batch_size, emb_dim)
       target_dim: target dimension to reduce the embedding to
   Return:
       np.array: Normalized 1D numpy array 
   '''
   smaller_embedding = embedding[..., :target_dim]
   if normalize:
      smaller_embedding = normalize_embedding(smaller_embedding)
   return smaller_embedding
   
   
if __name__ == '__main__':
   embedding = # bedrock client call
   reduced_embedding = # bedrock client call with dim=256
   post_reduction_embeddings = reduce_emb_dim(np.array(embeddings), dim=256)
   print(linalg.norm(np.array(reduced_embedding) - post_reduction_embeddings))