Tutoriel : Commencer avec le modèle de raisonnement DeepSeek-R1 dans Microsoft Foundry Modèles (classique)

Affichage actuel :Version du portail - Passer à la version du nouveau portail Foundry

Dans ce tutoriel, vous allez apprendre à déployer et à utiliser un modèle de raisonnement DeepSeek dans Microsoft Foundry. Ce tutoriel utilise DeepSeek-R1 pour l’illustration. Toutefois, le contenu s’applique également au modèle de raisonnement DeepSeek-R1-0528 plus récent.

Ce que vous effectuez :

Dans ce tutoriel, vous déployez le modèle de raisonnement DeepSeek-R1, envoyez des demandes d’inférence par programmation à l’aide du code et analysez la sortie du raisonnement pour comprendre comment le modèle arrive à ses réponses.

Les étapes que vous effectuez dans ce tutoriel sont les suivantes :

Créez et configurez les ressources Azure pour utiliser DeepSeek-R1 dans les modèles Foundry.
Configurez le déploiement du modèle.
Utilisez DeepSeek-R1 avec les API OpenAI de nouvelle génération v1 Azure pour utiliser le modèle dans le code.

Conditions préalables

Pour terminer cet article, vous avez besoin des éléments suivants :

Un abonnement Azure avec un mode de paiement valide. Si vous n'avez pas d'abonnement Azure, créez un compte payé Azure à commencer. Si vous utilisez des modèles GitHub, vous pouvez passer des modèles GitHub vers les modèles Foundry de Microsoft et créer un abonnement Azure au cours du processus.
Accès à Microsoft Foundry avec les autorisations appropriées pour créer et gérer des ressources. En général, le rôle de Contributeur ou de Propriétaire sur le groupe de ressources est requis pour créer des ressources et déployer des modèles.
Le rôle d’utilisateur Cognitive Services (ou supérieur) attribué à votre compte d’Azure dans la ressource Foundry. Ce rôle est nécessaire pour effectuer des appels d’inférence avec Microsoft Entra ID. Affectez-le dans le portail Azure sous Access Control (IAM) sur la ressource Foundry.
Installez le Kit de développement logiciel (SDK) OpenAI Azure pour votre langage de programmation :
- Python : pip install openai azure-identity
- .NET : dotnet add package OpenAI et dotnet add package Azure.Identity
- JavaScript : npm install openai @azure/identity
- Java : ajoutez les packages com.openai:openai-java et com.azure:azure-identity

DeepSeek-R1 est un modèle de raisonnement qui génère des explications en même temps que des réponses. Il prend en charge l'achèvement des conversations basées sur texte, mais ne prend pas en charge l'interaction avec des outils ou les formats de sortie structurés. Pour plus d’informations, voir À propos des modèles de raisonnement .

Créer les ressources

Pour créer un projet Foundry qui prend en charge le déploiement pour DeepSeek-R1, procédez comme suit. Vous pouvez également créer les ressources à l’aide de Azure CLI ou infrastructure en tant que code, avec Bicep.

Conseil

Comme vous pouvez customiser le volet gauche dans le portail Microsoft Foundry, vous pouvez voir des éléments différents de ceux indiqués dans ces étapes. Si vous ne voyez pas ce que vous recherchez, sélectionnez ... Plus en bas du volet gauche.

Connectez-vous à Microsoft Foundry. Assurez-vous que l'interrupteur New Foundry est désactivé. Ces étapes font référence à Foundry (classique).
Dans la page d’accueil, accédez à la section « Explorer les modèles et les fonctionnalités ».
Utilisez la zone de recherche sur l’écran pour rechercher le modèle DeepSeek-R1 et ouvrir sa carte de modèle.

Sélectionnez Utiliser ce modèle. Cette action ouvre un assistant pour créer un projet Foundry et des ressources pour votre travail. Vous pouvez conserver le nom par défaut du projet ou le modifier.

Conseil

Utilisez-vous Azure OpenAI dans les modèles Foundry ? Lorsque vous êtes connecté au portail Foundry à l'aide d'une ressource OpenAI Azure, seuls Azure modèles OpenAI apparaissent dans le catalogue. Pour afficher la liste complète des modèles, notamment DeepSeek-R1, utilisez la section Annonces supérieure et recherchez la carte avec l’option Explorer d’autres modèles.

Une nouvelle fenêtre s’ouvre avec la liste complète des modèles. Sélectionnez DeepSeek-R1 dans la liste, puis sélectionnez Déployer. L’assistant vous demande de créer un nouveau projet.

Sélectionnez la liste déroulante dans la section « Options avancées » de l’Assistant pour afficher des détails sur les paramètres et les autres valeurs par défaut créées en même temps que le projet. Ces valeurs par défaut sont sélectionnées pour des fonctionnalités optimales et incluent :

Propriété	Description
Groupe de ressources	Conteneur principal pour toutes les ressources de Azure. Ce conteneur vous aide à organiser les ressources qui fonctionnent ensemble. Il vous aide également à avoir une idée des coûts associés à l’ensemble du projet.
Région	Région des ressources que vous créez.
Ressource Fonderie	Ressource permettant d’accéder aux modèles phares dans le catalogue de modèles Foundry. Dans ce tutoriel, un nouveau compte est créé, mais les ressources Foundry (anciennement Azure ressource AI Services) peuvent être partagées entre plusieurs hubs et projets. Les hubs utilisent une connexion à la ressource pour accéder aux modèles de déploiement disponibles à cet emplacement. Pour savoir comment créer des connexions aux ressources Foundry pour consommer des modèles, consultez Connecter votre projet IA.

Sélectionnez Créer pour créer le projet Foundry en même temps que les autres valeurs par défaut. Attendez que la création du projet soit terminée. Ce processus prend quelques minutes.

Déployer le modèle

Lorsque vous créez le projet et les ressources, un assistant de déploiement s’ouvre. DeepSeek-R1 est disponible en tant que modèle Foundry vendu directement par Azure. Vous pouvez consulter les détails de tarification du modèle en sélectionnant l’onglet DeepSeek dans la page de tarification des modèles Foundry.
Configurez les paramètres de déploiement. Par défaut, le déploiement reçoit le nom du modèle que vous déployez. Le nom du déploiement est utilisé dans le paramètre model pour que les demandes soient routées vers ce déploiement de modèle particulier. Cette configuration vous permet de configurer des noms spécifiques pour vos modèles lorsque vous attachez des configurations spécifiques.
1. Foundry sélectionne automatiquement la ressource Foundry que vous avez créée précédemment avec votre projet. Utilisez l’option Personnaliser pour modifier la connexion en fonction de vos besoins. DeepSeek-R1 est disponible sous les types de déploiement Global Standard et Global Provisioned , qui offrent un débit et des performances plus élevés.
Sélectionnez Déployer.
Une fois le déploiement terminé, la page Détails du déploiement s’ouvre. Maintenant, le nouveau modèle est prêt à être utilisé.

Si vous préférez explorer le modèle de manière interactive, passez d’abord à utiliser le modèle dans le terrain de jeu.

Utiliser le modèle dans le code

Utilisez le point de terminaison et les informations d’identification des modèles Foundry pour vous connecter au modèle.

Utilisez les APIs Azure OpenAI v1 de nouvelle génération pour intégrer le modèle dans votre code. Ces exemples de code utilisent une approche d’authentification sécurisée sans clé, Microsoft Entra ID, via la bibliothèque Azure Identity.

Les exemples de code suivants montrent comment :

Authentifiez-vous avec Microsoft Entra ID à l’aide de DefaultAzureCredential, qui tente automatiquement plusieurs méthodes d’authentification (variables d’environnement, identité managée, Azure CLI et autres). L'ordre exact dépend de la version du Kit de développement logiciel (SDK) Azure Identity que vous utilisez.

Conseil

Pour le développement local, vérifiez que vous êtes authentifié avec Azure CLI en exécutant az login. Pour les déploiements de production dans Azure, configurez l’identité managée pour votre application.
Créer un client d’achèvement de conversation connecté à votre déploiement de modèle
Envoyer une invite de base au modèle DeepSeek-R1
Recevoir et afficher la réponse

Sortie attendue : Réponse JSON contenant la réponse du modèle, le processus de raisonnement (dans <think> les balises), les statistiques d’utilisation des jetons (jetons d’invite, jetons d’achèvement, jetons totaux) et les informations de modèle.

Installez les packages openai et azure-identity en utilisant votre gestionnaire de packages, comme pip :

pip install --upgrade openai azure-identity

L’exemple suivant montre comment créer un client pour consommer des complétions de chat, puis générer et afficher la réponse :


from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

client = OpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  api_key=token_provider,
)
response = client.chat.completions.create(
  model="DeepSeek-R1", # Replace with your model deployment name.
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "How many languages are in the world?"}
  ]
)

#print(response.choices[0].message)
print(response.model_dump_json(indent=2))

Tout d’abord, installez la bibliothèque de client Azure Identity avant de pouvoir utiliser DefaultAzureCredential :

Installez les packages openai et @azure/identity utilisez npm :

npm install openai @azure/identity

Pour authentifier le OpenAI client, utilisez la getBearerTokenProvider fonction à partir du @azure/identity package. Cette fonction crée un fournisseur de jetons qui OpenAI utilise en interne pour obtenir des jetons pour chaque requête.

Le code suivant crée le fournisseur de jetons, crée un client pour consommer des achèvements de conversation et génère la réponse :

import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
import { OpenAI } from "openai";

const tokenProvider = getBearerTokenProvider(
    new DefaultAzureCredential(),
    'https://ai.azure.com/.default');

const client = new OpenAI({
    baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    apiKey: tokenProvider
});

const messages = [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'How many languages are in the world?' }
];

// Make the API request with top-level await
const result = await client.chat.completions.create({ 
    messages, 
    model: 'DeepSeek-R1', // Your model deployment name
    max_tokens: 100 
});

// Print the full response
console.log('Full response:', result);

// Print just the message content from the response
console.log('Response content:', result.choices[0].message.content);

Tout d’abord, installez la bibliothèque d’identités Azure avant de pouvoir utiliser DefaultAzureCredential :

dotnet add package Azure.Identity

Utilisez le type d’informations d’identification souhaité émanant de la bibliothèque. Par exemple, DefaultAzureCredential. Créez ensuite le fournisseur de jetons, créez un client pour utiliser les complétions de conversations et générez la réponse.

using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;

#pragma warning disable OPENAI001

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");

ChatClient client = new(
    model: "DeepSeek-R1", // Replace with your model deployment name.
    authenticationPolicy: tokenPolicy,
    options: new OpenAIClientOptions() { 
        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1")
   }
);

ChatCompletion completion = client.CompleteChat("How many languages are in the world?");

Console.WriteLine($"[ASSISTANT]: {completion.Content[0].Text}");

L’authentification avec Microsoft Entra ID nécessite une configuration initiale :

Ajoutez le package Azure Identity :

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.18.0</version>
</dependency>

Après la configuration, vous pouvez choisir le type d’identifiant azure.identity à utiliser. Par exemple, DefaultAzureCredential vous pouvez l’utiliser pour authentifier le client.

L’authentification est simple à l’aide DefaultAzureCredentialde . Il trouve les meilleures informations d'authentification à utiliser dans son environnement d'exécution.

Credential tokenCredential = BearerTokenCredential.create(
        AuthenticationUtil.getBearerTokenSupplier(
                new DefaultAzureCredentialBuilder().build(),
                "https://ai.azure.com/.default"));
OpenAIClient client = OpenAIOkHttpClient.builder()
        .baseUrl("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/")
        .credential(tokenCredential)
        .build();

Pour plus d’informations sur Azure l’authentification sans clé OpenAI, consultez Utilisez Azure OpenAI sans clés.

Fin de conversation :

package com.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.ChatModel;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public class OpenAITest {
    public static void main(String[] args) {
        String resourceName = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
        String modelDeploymentName = "DeepSeek-R1"; // Replace with your model deployment name.

        try {
            OpenAIClient client = OpenAIOkHttpClient.builder()
                    .baseUrl(resourceName)
                    // Set the Azure Entra ID
                    .credential(BearerTokenCredential.create(AuthenticationUtil.getBearerTokenSupplier(
                        new DefaultAzureCredentialBuilder().build(), "https://ai.azure.com/.default")))
                    .build();

           ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
              .addUserMessage("How many languages are in the world?")
              .model(modelDeploymentName)
              .build();
           ChatCompletion chatCompletion = client.chat().completions().create(params);
        }
    }
}

curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
      "model": "DeepSeek-R1",
      "messages": [
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "How many languages are in the world?"
      }
    ]
  }'

Pour récupérer une réponse :

curl -X GET https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/chat/completions/{response_id} \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"

Conseil

Après avoir exécuté le code, vous devez voir une réponse JSON qui inclut choices[0].message.content la réponse du modèle. Si le modèle génère un raisonnement, la réponse contient du contenu encapsulé dans <think>...</think> des balises suivies de la réponse finale.

Informations de référence sur l’API :

Le raisonnement peut générer des réponses plus longues et consommer un plus grand nombre de jetons. DeepSeek-R1 prend en charge jusqu’à 5 000 requêtes par minute et 5 000 000 jetons par minute. Consultez les limites de débit qui s’appliquent aux modèles DeepSeek-R1. Envisagez d’avoir une stratégie de nouvelle tentative pour gérer les limites de débit. Vous pouvez également demander des augmentations aux limites par défaut.

À propos des modèles de raisonnement

Les modèles de raisonnement peuvent atteindre des niveaux de performances plus élevés dans des domaines tels que les mathématiques, le codage, la science, la stratégie et la logistique. La façon dont ces modèles produisent des sorties consiste explicitement à utiliser la chaîne de pensée pour explorer tous les chemins possibles avant de générer une réponse. Ils vérifient leurs réponses à mesure qu’ils les produisent, ce qui permet d’arriver à des conclusions plus précises. Par conséquent, les modèles de raisonnement peuvent nécessiter moins d’invites de contexte afin de produire des résultats efficaces.

Les modèles de raisonnement produisent deux types de contenu en tant que sorties :

Complétions de raisonnement
Achèvements de sortie

Ces deux complétions comptent pour le contenu généré par le modèle. Par conséquent, ils contribuent aux limites et coûts des jetons associés au modèle. Certains modèles, comme DeepSeek-R1, peuvent répondre avec le contenu du raisonnement. D’autres, comme o1, ne génèrent que les achèvements.

Contenu du raisonnement

Certains modèles de raisonnement, comme DeepSeek-R1, génèrent des complétions et incluent le raisonnement qui les sous-tend. Le raisonnement associé à l’achèvement est inclus dans le contenu de la réponse dans les balises <think> et </think>. Le modèle peut sélectionner les scénarios pour lesquels générer du contenu de raisonnement. L’exemple suivant montre comment générer le contenu du raisonnement à l’aide de Python :

import re

match = re.match(r"<think>(.*?)</think>(.*)", response.choices[0].message.content, re.DOTALL)

print("Response:")
if match:
    print("\tThinking:", match.group(1))
    print("\tAnswer:", match.group(2))
else:
    print("\tAnswer:", response.choices[0].message.content)
print("Model:", response.model)
print("Usage:")
print("\tPrompt tokens:", response.usage.prompt_tokens)
print("\tTotal tokens:", response.usage.total_tokens)
print("\tCompletion tokens:", response.usage.completion_tokens)

Thinking: Okay, the user is asking how many languages exist in the world. I need to provide a clear and accurate answer. Let's start by recalling the general consensus from linguistic sources. I remember that the number often cited is around 7,000, but maybe I should check some reputable organizations.\n\nEthnologue is a well-known resource for language data, and I think they list about 7,000 languages. But wait, do they update their numbers? It might be around 7,100 or so. Also, the exact count can vary because some sources might categorize dialects differently or have more recent data. \n\nAnother thing to consider is language endangerment. Many languages are endangered, with some having only a few speakers left. Organizations like UNESCO track endangered languages, so mentioning that adds context. Also, the distribution isn't even. Some countries or regions have hundreds of languages, like Papua New Guinea with over 800, while others have just a few. \n\nA user might also wonder why the exact number is hard to pin down. It's because the distinction between a language and a dialect can be political or cultural. For example, Mandarin and Cantonese are considered dialects of Chinese by some, but they're mutually unintelligible, so others classify them as separate languages. Also, some regions are under-researched, making it hard to document all languages. \n\nI should also touch on language families. The 7,000 languages are grouped into families like Indo-European, Sino-Tibetan, Niger-Congo, etc. Maybe mention a few of the largest families. But wait, the question is just about the count, not the families. Still, it's good to provide a bit more context. \n\nI need to make sure the information is up-to-date. Let me think – recent estimates still hover around 7,000. However, languages are dying out rapidly, so the number decreases over time. Including that note about endangerment and language extinction rates could be helpful. For instance, it's often stated that a language dies every few weeks. \n\nAnother point is sign languages. Does the count include them? Ethnologue includes some, but not all sources might. If the user is including sign languages, that adds more to the count, but I think the 7,000 figure typically refers to spoken languages. For thoroughness, maybe mention that there are also over 300 sign languages. \n\nSummarizing, the answer should state around 7,000, mention Ethnologue's figure, explain why the exact number varies, touch on endangerment, and possibly note sign languages as a separate category. Also, a brief mention of Papua New Guinea as the most linguistically diverse country/region. \n\nWait, let me verify Ethnologue's current number. As of their latest edition (25th, 2022), they list 7,168 living languages. But I should check if that's the case. Some sources might round to 7,000. Also, SIL International publishes Ethnologue, so citing them as reference makes sense. \n\nOther sources, like Glottolog, might have a different count because they use different criteria. Glottolog might list around 7,000 as well, but exact numbers vary. It's important to highlight that the count isn't exact because of differing definitions and ongoing research. \n\nIn conclusion, the approximate number is 7,000, with Ethnologue being a key source, considerations of endangerment, and the challenges in counting due to dialect vs. language distinctions. I should make sure the answer is clear, acknowledges the variability, and provides key points succinctly.

Answer: The exact number of languages in the world is challenging to determine due to differences in definitions (e.g., distinguishing languages from dialects) and ongoing documentation efforts. However, widely cited estimates suggest there are approximately **7,000 languages** globally.
Model: DeepSeek-R1
Usage: 
  Prompt tokens: 11
  Total tokens: 897
  Completion tokens: 886

Informations de référence sur l’API :

Modèles de raisonnement rapide

Lorsque vous créez des invites pour les modèles de raisonnement, prenez en compte les éléments suivants :

Utilisez des instructions simples et évitez d’utiliser des techniques de chaîne de pensée.
Les fonctionnalités de raisonnement intégrées rendent les invites simples sans tir aussi efficace que les méthodes plus complexes.
Lorsque vous fournissez un contexte ou des documents supplémentaires, comme dans les scénarios RAG, y compris uniquement les informations les plus pertinentes peuvent aider à empêcher le modèle de sur-compliquer sa réponse.
Les modèles de raisonnement peuvent prendre en charge l’utilisation des messages système. Toutefois, ils peuvent ne pas les suivre aussi strictement que d’autres modèles de non-raisonnement.
Lors de la création d’applications à plusieurs tour, envisagez d’ajouter uniquement la réponse finale du modèle, sans contenu de raisonnement, comme expliqué dans la section Contenu de raisonnement .

Notez que les modèles de raisonnement peuvent prendre plus de temps pour générer des réponses. Ils utilisent de longues chaînes de raisonnement qui permettent une résolution de problèmes plus profonde et plus structurée. Ils effectuent également une auto-vérification pour vérifier leurs réponses et corriger leurs erreurs, présentant ainsi des comportements autoréflexifs émergents.

Paramètres

Les modèles de raisonnement prennent en charge un sous-ensemble des paramètres d’achèvement de conversation standard pour maintenir l’intégrité de leur processus de raisonnement.

Paramètres pris en charge :

max_tokens - Nombre maximal de jetons à générer dans la réponse
stop - Séquences où l’API cesse de générer des jetons
stream - Activer les réponses en streaming
n - Nombre de complétions à générer

Paramètres non pris en charge (les modèles de raisonnement ne prennent pas en charge ces paramètres) :

temperature - Résolu pour optimiser la qualité du raisonnement
top_p - Non configurable pour les modèles de raisonnement
presence_penalty - Non disponible
repetition_penalty - Non disponible pour les modèles de raisonnement

Exemple utilisant max_tokens:

response = client.chat.completions.create(
    model="DeepSeek-R1",
    messages=[
        {"role": "user", "content": "Explain quantum computing"}
    ],
    max_tokens=1000  # Limit response length
)

Pour obtenir la liste complète des paramètres pris en charge, consultez la référence de l’API de complétions de chat.

Utiliser le modèle dans le terrain de jeu

Utilisez le modèle dans le terrain de jeu pour avoir une idée des fonctionnalités du modèle.

Dans la page détails du déploiement, sélectionnez Ouvrir dans le terrain de jeu dans la barre supérieure. Cette action ouvre le terrain de jeu de conversation.
Dans la liste déroulante Déploiement du terrain de jeu de conversation, le déploiement que vous avez créé est déjà sélectionné automatiquement.
Configurez l’invite système en fonction des besoins.
Saisissez votre invite et consultez les résultats.
Sélectionnez Afficher le code pour afficher des détails sur l’accès au déploiement du modèle par programmation.

Dépannage

Si vous rencontrez des problèmes lors de la suite de ce didacticiel, utilisez les conseils suivants pour résoudre les problèmes courants.

Erreurs d’authentification (401/403)

Vérifiez que vous êtes connecté à Azure CLI. Pour le développement local, exécutez az login avant d’exécuter votre code. DefaultAzureCredential utilise vos informations d’identification Azure CLI comme secours lorsqu’aucune autre information d’identification n’est disponible.
Vérifiez les attributions de rôles. Votre compte Azure a besoin du rôle d’utilisateur Cognitive Services (ou supérieur) sur la ressource Foundry pour effectuer des appels d’inférence avec Microsoft Entra ID. Si vous n'avez pas encore attribué ce rôle, consultez la section Pré-requis.
Vérifiez le format du point de terminaison. L’URL du point de terminaison doit suivre le format https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/. Vérifiez que le nom de la ressource correspond à votre ressource Foundry.

Problèmes de déploiement

Nom du déploiement et nom du modèle. Le model paramètre dans les appels d’API fait référence à votre nom de déploiement, et non au nom du modèle. Si vous avez personnalisé le nom du déploiement lors de la création, utilisez ce nom au lieu de DeepSeek-R1.
Le déploiement n’est pas prêt. Si vous recevez une erreur 404, vérifiez que l’état du déploiement affiche Réussi dans le portail Foundry avant d’effectuer des appels d’API.

Limitation du débit (429 erreurs)

Implémentez la logique de nouvelle tentative. Les modèles de raisonnement génèrent des réponses plus longues qui consomment davantage de jetons. Utilisez l'attente exponentielle pour gérer les erreurs 429 (Trop de requêtes).
Surveillez l’utilisation des jetons. Le contenu de raisonnement DeepSeek-R1 (entre les balises <think>) est comptabilisé dans votre limite de jetons. Consultez les quotas et les limites des limites de taux actuelles.
Demander des augmentations de quota. Si vous atteignez constamment des limites de taux, la requête augmente aux limites par défaut.

Problèmes d’installation de package

Python. Installez les deux packages requis : pip install openai azure-identity. Le azure-identity package est requis pour DefaultAzureCredential.
Javascript. Installez les deux packages requis : npm install openai @azure/identity.
.NET. Installez le package Azure Identity : dotnet add package Azure.Identity.

Ce que vous avez appris

Dans ce tutoriel, vous avez effectué les opérations suivantes :

Ressources Foundry créées pour l’hébergement de modèles IA
Déploiement du modèle de raisonnement DeepSeek-R1
Appels d’API authentifiés à l’aide de Microsoft Entra ID
Demandes d’inférence envoyées et sorties de raisonnement reçues
Contenu de raisonnement analysé à partir des réponses de modèle pour comprendre le processus de pensée du modèle

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-05-01