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.

# DeepSeek Modèles  
<a name="model-parameters-deepseek"></a>

DeepSeek[R1 et les V3.1 modèles sont des modèles de synthèse texte disponibles pour l'inférence via l'API Invoke ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html), [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) et l'API Converse (Converse et). [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) 

Lorsque vous effectuez des appels d’inférence avec des modèles DeepSeek, incluez une invite pour ce modèle. Pour obtenir des informations générales sur la création d’invites pour les modèles DeepSeek pris en charge par Amazon Bedrock, consultez le [Guide d’invites DeepSeek](https://api-docs.deepseek.com/guides/reasoning_model). 

**Note**  
Vous ne pouvez pas supprimer la demande d'accès aux modèles Amazon Titan, Amazon Nova DeepSeek-R1, Mistral AI, Meta Llama 3 Instruct et Meta Llama 4. Vous pouvez empêcher les utilisateurs d’effectuer des appels d’inférence vers ces modèles en utilisant une politique IAM et en spécifiant l’ID du modèle. Pour plus d’informations, consultez [Refus de l’accès à des fins d’inférence de modèles de fondation](https://docs.aws.amazon.com/bedrock/latest/userguide/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-deny-inference                         .html).
Pour une qualité de réponse optimaleDeepSeek-R1, limitez le `max_tokens` paramètre à 8 192 jetons ou moins. Bien que l'API accepte jusqu'à 32 768 jetons, la qualité de réponse se dégrade considérablement au-dessus de 8 192 jetons. Cela correspond aux capacités de raisonnement du modèle telles que décrites dans le guide de [raisonnement par inférence](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-reasoning.html).

Cette section décrit les paramètres de demande et les champs de réponse pour les modèles DeepSeek. Utilisez ces informations pour effectuer des appels d'inférence aux DeepSeek modèles avec l'[InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)opération. Cette section inclut également des exemples de code Python qui montrent comment appeler des modèles DeepSeek.

Pour utiliser un modèle dans une opération d’inférence, vous avez besoin de l’ID du modèle. Comme ce modèle est invoqué par inférence interrégionale, vous devez utiliser l’ID de l’[ID du profil d’inférence](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html) comme ID du modèle. Par exemple, pour les USA, vous utilisez `us.deepseek.r1-v1:0`.
+ Nom du modèle : DeepSeek-R1
+ Modèle de texte

Pour plus d’informations sur l’utilisation des modèles DeepSeek avec des API, consultez [Modèles DeepSeek](https://deepseek.com/).

**Demande et réponse DeepSeek**

**Corps de la demande**

DeepSeek comporte les paramètres d’inférence suivants pour un appel d’inférence de complétion de texte.

```
{
    "prompt": string,
    "temperature": float, 
    "top_p": float,
    "max_tokens": int,
    "stop": string array
}
```

**Champs :**
+ **prompt** : (chaîne) entrée de texte requise pour l’invite.
+ **temperature** : (valeur flottante) valeur numérique inférieure ou égale à 1.
+ **top\_p** : (valeur flottante) valeur numérique inférieure ou égale à 1.
+ **max\_tokens** — (int) Jetons utilisés, d'un minimum de 1 à un maximum de 8 192 jetons pour une qualité optimale. Bien que l'API accepte jusqu'à 32 768 jetons, la qualité de réponse se dégrade considérablement au-dessus de 8 192 jetons.
+ **stop** : (tableau de chaînes) maximum de 10 éléments.

**Organisme de réponse**

DeepSeek comporte les paramètres de réponse inférence suivants pour un appel d’inférence de complétion de texte. Cet exemple est une complétion de texte à partir de DeepSeek et ne renvoie aucun bloc de raisonnement relatif au contenu.

```
{
    "choices": [
        {
            "text": string,
            "stop_reason": string
        }
    ]
}
```

**Champs :**
+ **stop\_reason** : (chaîne) raison pour laquelle la réponse a cessé de générer du texte. Valeur de `stop` ou `length`.
+ **stop** : (chaîne) le modèle a fini de générer le texte pour l’invite d’entrée.
+ **length** : (chaîne) la longueur des jetons pour le texte généré dépasse la valeur de `max_tokens` dans l’appel `InvokeModel` (`InvokeModelWithResponseStream`, si vous diffusez une sortie). La réponse est tronquée à `max_tokens`. Augmentez la valeur de `max_tokens` et renouvelez votre demande.

**Exemple de code**

Cet exemple montre comment appeler le modèle DeepSeek-R1.

```
# Use the API to send a text message to DeepSeek-R1.

import boto3
import json

from botocore.exceptions import ClientError

# Create a Bedrock Runtime client in the Région AWS of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")

# Set the cross Region inference profile ID for DeepSeek-R1
model_id = "us.deepseek.r1-v1:0"

# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."

# Embed the prompt in DeepSeek-R1's instruction format.
formatted_prompt = f"""
<｜begin▁of▁sentence｜><｜User｜>{prompt}<｜Assistant｜><think>\n
"""

body = json.dumps({
    "prompt": formatted_prompt,
    "max_tokens": 512,
    "temperature": 0.5,
    "top_p": 0.9,
})

try:
    # Invoke the model with the request.
    response = client.invoke_model(modelId=model_id, body=body)

    # Read the response body.
    model_response = json.loads(response["body"].read())
    
    # Extract choices.
    choices = model_response["choices"]
    
    # Print choices.
    for index, choice in enumerate(choices):
        print(f"Choice {index + 1}\n----------")
        print(f"Text:\n{choice['text']}\n")
        print(f"Stop reason: {choice['stop_reason']}\n")
except (ClientError, Exception) as e:
    print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
    exit(1)
```

**Converse**

Corps de la demande : utilisez cet exemple de corps de la demande pour appeler l’API ConverseAPI.

```
{
    "modelId": string, # us.deepseek.r1-v1:0
    "system": [
        {
            "text": string
        }
    ],
    "messages": [
        {
            "role": string,
            "content": [
                {
                    "text": string
                }
            ]
        }
    ],
    "inferenceConfig": {
        "temperature": float,
        "topP": float,
        "maxTokens": int,
        "stopSequences": string array
    },
    "guardrailConfig": { 
        "guardrailIdentifier":"string",
        "guardrailVersion": "string",
        "trace": "string"
    }
}
```

**Champs :**
+ **system** : (facultatif) invite du système pour la demande.
+ **messages** : (obligatoire) les messages d’entrée.
  + **role** : le rôle du tour de conversation. Les valeurs valides sont `user` et `assistant`.
  + **content** : (obligatoire) le contenu de la conversation prend la forme d’un tableau d’objets. Chaque objet contient un champ type dans lequel vous pouvez spécifier l’une des valeurs suivantes :
    + **text** : (obligatoire) si vous spécifiez ce type, vous devez inclure un champ texte et spécifier l’invite de texte comme valeur.
+ **inferenceConfig** 
  + **temperature** : (facultatif) valeurs : minimum = 0. maximum = 1.
  + **topP** : (facultatif) valeurs : minimum = 0. Maximum = 1.
  + **maxTokens** : (facultatif) nombre maximum de jetons à générer avant l’arrêt. Valeurs : minimum = 0. Maximum = 32 768.
  + **stopSequences** : (facultatif) séquences de texte personnalisées qui empêchent le modèle de générer une sortie. Maximum = 10 éléments.

Corps de la réponse : utilisez cet exemple de corps de la demande pour appeler l’API Converse.

```
{
    "message": {
        "role" : "assistant",
        "content": [
            {
                "text": string
            },
            {
                "reasoningContent": {
                    "reasoningText": string
                }
            }
        ],
    },
    "stopReason": string,
    "usage": {
        "inputTokens": int,
        "outputTokens": int,
        "totalTokens": int
    }
    "metrics": {
        "latencyMs": int
    }
}
```

**Champs :**
+ **message** : réponse renvoyée par le modèle.
+ **role** : rôle conversationnel du message généré. La valeur est toujours `assistant`.
+ **content** : contenu généré par le modèle, qui est renvoyé sous forme de tableau. Il existe deux types contenus :
  + **text** : contenu textuel de la réponse.
  + **reasoningContent** : (facultatif) contenu du raisonnement issu de la réponse du modèle.
    + **reasoningText** : texte de raisonnement issu de la réponse du modèle.
+ **stopReason** : raison pour laquelle le modèle a cessé de générer la réponse. 
  + **end\_turn** : tour auquel le modèle a atteint un point d’arrêt.
  + **max\_tokens** : le texte généré dépassait la valeur du champ d’entrée `maxTokens` ou le nombre maximum de jetons pris en charge par le modèle.

Exemple de code - Voici un exemple de DeepSeek création d'un appel à la ConverseAPI.

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Converse API with DeepSeek-R1 (on demand).
"""

import logging
import boto3

from botocore.client import Config
from botocore.exceptions import ClientError


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


def generate_conversation(bedrock_client,
                          model_id,
                          system_prompts,
                          messages):
    """
    Sends messages to a model.
    Args:
        bedrock_client: The Boto3 Bedrock runtime client.
        model_id (str): The model ID to use.
        system_prompts (JSON) : The system prompts for the model to use.
        messages (JSON) : The messages to send to the model.

    Returns:
        response (JSON): The conversation that the model generated.

    """

    logger.info("Generating message with model %s", model_id)

    # Inference parameters to use.
    temperature = 0.5
    max_tokens = 4096

    # Base inference parameters to use.
    inference_config = {
        "temperature": temperature,
        "maxTokens": max_tokens,
    }

    # Send the message.
    response = bedrock_client.converse(
        modelId=model_id,
        messages=messages,
        system=system_prompts,
        inferenceConfig=inference_config,
    )

    # Log token usage.
    token_usage = response['usage']
    logger.info("Input tokens: %s", token_usage['inputTokens'])
    logger.info("Output tokens: %s", token_usage['outputTokens'])
    logger.info("Total tokens: %s", token_usage['totalTokens'])
    logger.info("Stop reason: %s", response['stopReason'])

    return response

def main():
    """
    Entrypoint for DeepSeek-R1 example.
    """

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

    model_id = "us.deepseek.r1-v1:0"

    # Setup the system prompts and messages to send to the model.
    system_prompts = [{"text": "You are an app that creates playlists for a radio station that plays rock and pop music. Only return song names and the artist."}]
    message_1 = {
        "role": "user",
        "content": [{"text": "Create a list of 3 pop songs."}]
    }
    message_2 = {
        "role": "user",
        "content": [{"text": "Make sure the songs are by artists from the United Kingdom."}]
    }
    messages = []

    try:
        # Configure timeout for long responses if needed
        custom_config = Config(connect_timeout=840, read_timeout=840)
        bedrock_client = boto3.client(service_name='bedrock-runtime', config=custom_config)

        # Start the conversation with the 1st message.
        messages.append(message_1)
        response = generate_conversation(
            bedrock_client, model_id, system_prompts, messages)

        # Add the response message to the conversation.
        output_message = response['output']['message']
        
        # Remove reasoning content from the response
        output_contents = []
        for content in output_message["content"]:
            if content.get("reasoningContent"):
                continue
            else:
                output_contents.append(content)
        output_message["content"] = output_contents
        
        messages.append(output_message)

        # Continue the conversation with the 2nd message.
        messages.append(message_2)
        response = generate_conversation(
            bedrock_client, model_id, system_prompts, messages)

        output_message = response['output']['message']
        messages.append(output_message)

        # Show the complete conversation.
        for message in messages:
            print(f"Role: {message['role']}")
            for content in message['content']:
                if content.get("text"):
                    print(f"Text: {content['text']}")
                if content.get("reasoningContent"):
                    reasoning_content = content['reasoningContent']
                    reasoning_text = reasoning_content.get('reasoningText', {})
                    print()
                    print(f"Reasoning Text: {reasoning_text.get('text')}")
            print()

    except ClientError as err:
        message = err.response['Error']['Message']
        logger.error("A client error occurred: %s", message)
        print(f"A client error occured: {message}")

    else:
        print(
            f"Finished generating text with model {model_id}.")


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