Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Amazon Titan Embeddings G1 - Text
<a name="model-parameters-titan-embed-text"></a>

Titan Embeddings G1 - Text ne 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.

**Topics**
+ [Demande et réponse](#model-parameters-titan-embed-text-request-response)
+ [Exemple de code](#api-inference-examples-titan-embed-text)

## Demande et réponse
<a name="model-parameters-titan-embed-text-request-response"></a>

Le corps de la demande est transmis dans le champ `body` d’une demande [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html). 

------
#### [ V2 Request ]

Le paramètre inputText est obligatoire. Les paramètres de normalisation et de dimensions sont facultatifs.
+ inputText : entrez le texte à convertir en vectorisation.
+ normalize : (facultatif) indicateur permettant de déterminer s’il faut normaliser ou non la vectorisation de sortie. La valeur par défaut est true (vrai).
+ dimensions : (facultatif) nombre de dimensions que la vectorisation de sortie doit avoir. Les valeurs suivantes sont acceptées : 1024 (par défaut), 512, 256.
+ embeddingTypes : (facultatif) accepte une liste contenant « float », « binary » ou les deux. La valeur par défaut est `float`. 

```
{
    "inputText": string,
    "dimensions": int,
    "normalize": boolean,
    "embeddingTypes": list
}
```

------
#### [ V2 Response ]

Les champs sont décrits ci-dessous.
+ embedding : tableau qui représente le vecteur de vectorisation de l’entrée que vous avez fournie. Ce sera toujours du type `float`.
+ inputTextTokenCount : nombre de jetons figurant dans l’entrée.
+ embeddingsByType : dictionnaire ou carte de la liste de vectorisation. Cela dépend de l’entrée, des listes « float », « binary » ou des deux.
  + Exemple : `"embeddingsByType": {"binary": [int,..], "float": [float,...]}`
  + Ce champ apparaîtra toujours. Même si vous ne spécifiez pas `embeddingTypes` dans votre entrée, il y aura toujours « float ». Exemple : `"embeddingsByType": {"float": [float,...]}`

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

------
#### [ G1 Request ]

Le seul champ disponible est `inputText`, dans lequel vous pouvez inclure du texte à convertir en vectorisation.

```
{
    "inputText": string
}
```

------
#### [ G1 Response ]

Le `body` de la réponse contient les champs suivants.

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

Les champs sont décrits ci-dessous.
+ **embedding** : tableau qui représente le vecteur de vectorisation de l’entrée que vous avez fournie.
+ **inputTextTokenCount** : nombre de jetons figurant dans l’entrée.

------

## Exemple de code
<a name="api-inference-examples-titan-embed-text"></a>

Les exemples suivants montrent comment appeler les modèles de vectorisation Amazon Titan pour générer une vectorisation. Sélectionnez l’onglet qui correspond 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 an embedding 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_embedding(model_id, body):
    """
    Generate an embedding with the vector representation of 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 an embedding 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_embedding(model_id, body)

        print(f"Generated an embedding: {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 an embedding with Amazon Titan Embeddings G1 - Text model {model_id}.")


if __name__ == "__main__":
    main()
```

------
#### [ Amazon Titan Text Embeddings V2 ]

Lors de l’utilisation de Titan Text Embeddings V2, le champ `embedding` ne figure pas dans la réponse si le `embeddingTypes` contient uniquement `binary`. 

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an embedding 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_embedding(model_id, body):
    """
    Generate an embedding with the vector representation of 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 an embedding 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,
        "embeddingTypes": ["binary"]
    })


    try:

        response = generate_embedding(model_id, body)

        print(f"Generated an embedding: {response['embeddingsByType']['binary']}") # returns binary embedding
        print(f"Input text: {input_text}")
        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 an embedding with Amazon Titan Text Embeddings V2 model {model_id}.")


if __name__ == "__main__":
    main()
```

------