Tutoriel : Commencer avec le modèle de raisonnement DeepSeek-R1 dans les modèles de Microsoft 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 allez accomplir :

Dans ce tutoriel, vous allez déployer le modèle de raisonnement DeepSeek-R1, envoyer des demandes d’inférence par programmation à l’aide du code et analyser 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 Azure OpenAI de nouvelle génération v1 pour utiliser le modèle dans le code.

Conditions préalables

Pour effectuer ce qui est décrit dans cet article, vous avez besoin des éléments suivants :

• Un abonnement Azure avec un moyen de paiement valide. Si vous ne disposez pas d’un abonnement Azure, commencez par créer un compte Azure payant. Si vous utilisez des modèles GitHub, vous pouvez effectuer une mise à niveau des modèles GitHub vers microsoft Foundry Models et créer un abonnement Azure dans le processus.

• Accès à Microsoft Foundry avec les autorisations appropriées pour créer et gérer des ressources. Généralement, nécessite le rôle de Contributeur ou de Propriétaire sur le groupe de ressources pour créer des ressources et déployer des modèles.

• Installez le Kit de développement logiciel (SDK) Azure OpenAI pour votre langage de programmation :

  • Python : pip install openai azure-identity
  • .NET : dotnet add package Azure.Identity et installer le package OpenAI
  • JavaScript : npm install openai @azure/identity
  • Java : Ajouter le package Azure Identity (consultez des exemples de code pour plus d’informations)

DeepSeek-R1 est un modèle de raisonnement qui génère des explications en même temps que des réponses, voir À propos des modèles de raisonnement pour plus d’informations.

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 d’Azure CLI ou d’une infrastructure en tant que code, avec Bicep.

Déployer le modèle

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 API Azure OpenAI de nouvelle génération v1 pour consommer 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 :

1. Authentifiez-vous avec Microsoft Entra ID en utilisant DefaultAzureCredential, qui tente automatiquement plusieurs méthodes d’authentification successivement :

   1. Variables d’environnement : vérifie les informations d’identification de l’entité de service dans les variables d’environnement
   2. Identité managée : utilise l’identité managée si elle s’exécute dans Azure (App Service, Functions, machine virtuelle, etc.)
   3. Azure CLI - Revient aux informations d’identification Azure CLI si vous êtes authentifié localement
   4. Autres méthodes : continue par le biais de méthodes d’authentification supplémentaires selon les besoins

   Conseil / Astuce

   Pour le développement local, vérifiez que vous êtes authentifié auprès d’Azure CLI en exécutant az login. Pour les déploiements de production dans Azure, configurez l’identité managée pour votre application.

2. Créer un client d’achèvement de conversation connecté à votre déploiement de modèle

3. Envoyer une invite de base au modèle DeepSeek-R1

4. 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.

pip install --upgrade openai

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

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://cognitiveservices.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))

npm install @azure/identity

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

const tokenProvider = getBearerTokenProvider(
    new DefaultAzureCredential(),
    'https://cognitiveservices.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);

dotnet add package Azure.Identity

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

#pragma warning disable OPENAI001

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://cognitiveservices.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}");

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

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

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 you model deployment name

        try {
            OpenAIClient client = OpenAIOkHttpClient.builder()
                    .baseUrl(resourceName)
                    // Set the Azure Entra ID
                    .credential(BearerTokenCredential.create(AuthenticationUtil.getBearerTokenSupplier(
                        new DefaultAzureCredentialBuilder().build(), "https://cognitiveservices.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?"
      }
    ]
  }'

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"

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

• Client Python OpenAI
• Client OpenAI pour JavaScript
• Client OpenAI .NET
• Classe DefaultAzureCredential
• Référence API pour les complétions de conversation
• Vue d’ensemble de la bibliothèque d’identités Azure

Le raisonnement peut générer des réponses plus longues et consommer un plus grand nombre de jetons. Consultez les limites de débit qui s’appliquent aux modèles DeepSeek-R1. Envisagez d’avoir une stratégie de réessai 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
• Complétions 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 de 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 de 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 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. \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 :

• Documentation sur le nouveau module Python
• Informations de référence sur l’objet ChatCompletion

Modèles de raisonnement rapide

Lorsque vous élaborez des consignes pour des modèles de raisonnement, tenez compte des éléments suivants :

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 flux
• n - Nombre de complétions à générer
• frequency_penalty - Réduit la répétition des séquences de jetons

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 - Utiliser frequency_penalty à la place

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 des 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.

Ce que vous avez appris

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

Contenu connexe

• Comment générer des achèvements de conversation avec des modèles Foundry
• Utiliser des modèles de raisonnement de conversation
• Langages de programmation pris en charge par Azure OpenAI