Tutorial: Mulai menggunakan model penalaran DeepSeek-R1 dalam model Microsoft Foundry

Dalam tutorial ini, Anda mempelajari cara menyebarkan dan menggunakan model penalaran DeepSeek di Microsoft Foundry. Tutorial ini menggunakan DeepSeek-R1 untuk ilustrasi. Namun, konten juga berlaku untuk model penalaran DeepSeek-R1-0528 yang lebih baru.

Apa yang Anda capai:

Dalam tutorial ini, Anda menyebarkan model penalaran DeepSeek-R1, mengirim permintaan inferensi secara terprogram menggunakan kode, dan mengurai output penalaran untuk memahami bagaimana model tiba pada jawabannya.

Langkah-langkah yang Anda lakukan dalam tutorial ini adalah:

• Buat dan konfigurasikan sumber daya Azure untuk menggunakan DeepSeek-R1 di Model Foundry.
• Konfigurasikan penyebaran model.
• Gunakan DeepSeek-R1 dengan API OpenAI Azure generasi berikutnya v1 untuk mengonsumsi model di dalam kode.

Prasyarat

Untuk menyelesaikan artikel ini, Anda memerlukan:

• Langganan Azure dengan metode pembayaran yang valid. Jika Anda tidak memiliki langganan Azure, buat akun Azure bayar untuk memulai. Jika Anda menggunakan Model GitHub, Anda dapat upgrade dari Model GitHub ke Model Foundry Microsoft dan membuat langganan Azure dalam prosesnya.

• Akses ke Microsoft Foundry dengan izin yang sesuai untuk membuat dan mengelola sumber daya. Biasanya memerlukan peran Kontributor atau Pemilik pada grup sumber daya untuk membuat sumber daya dan menyebarkan model.

• Peran Cognitive Services User (atau peran lebih tinggi) yang ditetapkan ke akun Azure Anda pada sumber daya Foundry. Peran ini diperlukan untuk melakukan panggilan inferensi dengan Microsoft Entra ID. Tetapkan di portal Azure di bawah Access Control (IAM) pada sumber daya Foundry.

• Instal Azure OpenAI SDK untuk bahasa pemrograman Anda:

  • Python: pip install openai azure-identity
  • .NET: dotnet add package OpenAI dan dotnet add package Azure.Identity
  • JavaScript: npm install openai @azure/identity
  • Java: Tambahkan paket /> com.openai:openai-java dan com.azure:azure-identity

DeepSeek-R1 adalah model penalaran yang menghasilkan penjelasan bersama jawaban. Ini mendukung penyelesaian obrolan berbasis teks tetapi tidak mendukung panggilan alat atau format output terstruktur. Lihat Tentang model penalaran untuk detailnya.

Buat sumber daya

Untuk membuat proyek Foundry yang mendukung penyebaran untuk DeepSeek-R1, ikuti langkah-langkah ini. Anda juga dapat membuat sumber daya menggunakan Azure CLI atau infrastructure sebagai kode, dengan Bicep.

1. Masuk ke Microsoft Foundry. Pastikan tombol New Foundry aktif. Langkah-langkah ini mengacu pada Foundry (baru).
2. Proyek yang sedang Anda kerjakan muncul di sudut kiri atas.
3. Untuk membuat proyek baru, pilih nama proyek, lalu Buat proyek baru.
4. Beri nama proyek Anda dan pilih Buat proyek.

Pengimplementasian model

1. Tambahkan model ke proyek Anda. Pilih Bangun di tengah halaman, lalu Model.
2. Pilih Sebarkan model dasar untuk membuka katalog model.
3. Temukan dan pilih petak peta model DeepSeek-R1 untuk membuka kartu modelnya dan pilih Sebarkan. Anda dapat memilih Penyebaran cepat untuk menggunakan default, atau pilih Sesuaikan penyebaran untuk melihat dan mengubah pengaturan penyebaran.

Setelah penyebaran selesai, Anda masuk ke lingkungan uji coba, tempat Anda dapat mulai berinteraksi dengan aplikasi yang telah dikerahkan. Konfirmasikan penyebaran Anda siap dengan memverifikasi status penyebaran menunjukkan Berhasil. Perhatikan nama penyebaran dan URI titik akhir dari detail penyebaran—Anda memerlukan keduanya untuk bagian kode.

Jika Anda lebih suka menjelajahi model secara interaktif terlebih dahulu, lanjutkan ke Gunakan model di playground.

Menggunakan model dalam kode

Gunakan endpoint Foundry Models dan kredensial untuk menyambungkan ke model.

1. Pilih panel Detail dari panel atas Playgrounds untuk melihat detail penyebaran. Di sini, Anda dapat menemukan URI penyebaran dan kunci API.
2. Dapatkan nama sumber daya Anda dari URI penyebaran untuk digunakan untuk menyimpulkan model melalui kode.

Gunakan API OpenAI Azure v1 generasi berikutnya untuk menggunakan model dalam kode Anda. Contoh kode ini menggunakan pendekatan autentikasi tanpa kunci yang aman, Microsoft Entra ID, melalui pustaka identitas Azure.

Contoh kode berikut menunjukkan cara:

1. Autentikasi dengan Microsoft Entra ID menggunakan DefaultAzureCredential, yang secara otomatis mencoba beberapa metode autentikasi (variabel lingkungan, identitas terkelola, Azure CLI, dan lainnya). Urutan yang tepat tergantung pada versi Azure Identity SDK yang Anda gunakan.

   Petunjuk / Saran

   Untuk pengembangan lokal, pastikan Anda diautentikasi dengan Azure CLI dengan menjalankan az login. Untuk penyebaran produksi di Azure, konfigurasikan identitas terkelola untuk aplikasi Anda.

2. Membuat klien penyelesaian obrolan yang tersambung ke penyebaran model Anda

3. Mengirim permintaan dasar ke model DeepSeek-R1

4. Menerima dan menampilkan respons

Output yang diharapkan: Respons JSON yang berisi jawaban model, proses penalaran (dalam <think> tag), statistik penggunaan token (token perintah, token penyelesaian, token total), dan informasi model.

Python

Instal paket openai dan azure-identity gunakan manajer paket Anda, seperti pip:

pip install --upgrade openai azure-identity

Contoh berikut menunjukkan cara membuat client untuk mengkonsumsi hasil penyelesaian obrolan, kemudian menghasilkan dan mencetak respons.

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))

JavaScript

Pertama-tama instal pustaka klien Azure Identity sebelum Anda dapat menggunakan DefaultAzureCredential:

Instal paket openai dan @azure/identity gunakan npm:

npm install openai @azure/identity

Untuk mengautentikasi klien OpenAI, gunakan fungsi getBearerTokenProvider dari paket @azure/identity. Fungsi ini membuat penyedia token yang OpenAI menggunakan secara internal untuk mendapatkan token untuk setiap permintaan.

Kode berikut membuat penyedia token, membuat klien untuk mengakses hasil obrolan, dan menghasilkan respons:

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);

C#

Pertama-tama instal pustaka identitas Azure sebelum Anda dapat menggunakan DefaultAzureCredential:

dotnet add package Azure.Identity

Gunakan jenis kredensial yang diinginkan dari pustaka. Contohnya, DefaultAzureCredential. Kemudian buat penyedia token, buat klien untuk menggunakan penyelesaian obrolan, dan hasilkan balasan.

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}");

Java

Autentikasi dengan Microsoft Entra ID memerlukan beberapa penyiapan awal:

Tambahkan paket identitas Azure:

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

Setelah penyiapan, Anda dapat memilih jenis kredensial mana yang ingin Anda gunakan. Sebagai contoh, DefaultAzureCredential dapat digunakan untuk mengautentikasi klien.

Autentikasi mudah menggunakan DefaultAzureCredential. Ini menemukan kredensial terbaik untuk digunakan di lingkungan operasionalnya.

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();

Untuk informasi selengkapnya tentang autentikasi tanpa kunci Azure OpenAI, lihat Gunakan Azure OpenAI tanpa kunci.

Finalisasi obrolan:

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);
        }
    }
}

REST

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?"
      }
    ]
  }'

Untuk mendapatkan respons:

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"

Petunjuk / Saran

Setelah menjalankan kode, Anda akan melihat respons JSON yang menyertakan choices[0].message.content jawaban model. Jika model menghasilkan penalaran, respons berisi konten yang dibungkus dalam <think>...</think> tag diikuti dengan jawaban akhir.

Referensi API:

• klien OpenAI Python
• Klien OpenAI JavaScript
• Klien .NET OpenAI
• Kelas DefaultAzureCredential
• Referensi API untuk Chat Completions
• Gambaran umum pustaka Azure Identity

Penalaran dapat menghasilkan respons yang lebih lama dan menggunakan sejumlah besar token. DeepSeek-R1 mendukung hingga 5.000 permintaan per menit dan 5.000.000 token per menit. Lihat batas tarif yang berlaku untuk model DeepSeek-R1. Pertimbangkan untuk memiliki strategi coba lagi untuk menangani batas laju. Anda juga dapat meminta peningkatan ke batas default.

Tentang model penalaran

Model penalaran dapat mencapai tingkat performa yang lebih tinggi di domain seperti matematika, pengkodean, sains, strategi, dan logistik. Cara model ini menghasilkan output adalah dengan secara eksplisit menggunakan rantai pemikiran untuk menjelajahi semua jalur yang mungkin sebelum menghasilkan jawaban. Mereka memverifikasi jawaban mereka saat mereka menghasilkannya, yang membantu mencapai kesimpulan yang lebih akurat. Akibatnya, model penalaran mungkin memerlukan lebih sedikit permintaan konteks untuk menghasilkan hasil yang efektif.

Model penalaran menghasilkan dua jenis konten sebagai output:

• Penyelesaian Logika
• Penyempurnaan hasil

Kedua penyelesaian ini diperhitungkan sebagai konten yang dihasilkan dari model. Oleh karena itu, mereka berkontribusi pada batas token dan biaya yang terkait dengan model. Beberapa model, seperti DeepSeek-R1, mungkin merespons dengan konten penalaran. Lainnya, seperti o1, hanya menghasilkan penyelesaian.

Materi Penalaran

Beberapa model penalaran, seperti DeepSeek-R1, menghasilkan penyelesaian dan menyertakan penalaran di belakangnya. Penalaran yang terkait dengan penyelesaian disertakan dalam konten respons dalam tag <think> dan </think>. Model dapat memilih skenario untuk menghasilkan konten penalaran. Contoh berikut menunjukkan cara menghasilkan konten penalaran, menggunakan 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

Referensi API:

• Dokumentasi Modul Python re
• Referensi objek ChatCompletion

Model pemicu penalaran

Saat membuat permintaan untuk model penalaran, pertimbangkan hal berikut:

• Gunakan instruksi sederhana dan hindari menggunakan teknik rantai pemikiran.
• Kemampuan penalaran bawaan membuat perintah zero-shot sederhana sama efektifnya dengan metode yang lebih kompleks.
• Dalam skenario seperti RAG, saat memberikan konteks atau dokumen tambahan, termasuk hanya informasi yang paling relevan dapat membantu mencegah model terlalu mempersulit responsnya.
• Model penalaran dapat mendukung penggunaan pesan sistem. Namun, mereka mungkin tidak mengikutinya dengan ketat seperti model non-penalaran lainnya.
• Saat membuat aplikasi multi-giliran, pertimbangkan untuk menambahkan hanya jawaban akhir dari model, tanpa konten penalaran, seperti yang dijelaskan di bagian Konten penalaran .

Perhatikan bahwa model penalaran dapat memakan waktu lebih lama untuk menghasilkan respons. Mereka menggunakan rantai pemikiran penalaran panjang yang memungkinkan pemecahan masalah yang lebih dalam dan lebih terstruktur. Mereka juga melakukan verifikasi diri untuk memeriksa jawaban mereka dan memperbaiki kesalahan, sehingga menampilkan perilaku reflektif diri yang berkembang.

Parameter-parameternya

Model penalaran mendukung subset parameter penyelesaian percakapan standar guna mempertahankan integritas proses penalaran mereka.

Parameter yang didukung:

• max_tokens - Jumlah maksimum token yang dihasilkan dalam respons
• stop - Urutan di mana API berhenti menghasilkan token
• stream - Mengaktifkan respons streaming
• n - Jumlah penyelesaian yang akan dihasilkan

Parameter yang tidak didukung (model penalaran tidak mendukung ini):

• temperature - Diperbaiki untuk mengoptimalkan kualitas penalaran
• top_p - Tidak konfigurasional untuk model pemikiran
• presence_penalty - Tidak tersedia
• repetition_penalty - Tidak tersedia untuk model penalaran

Contoh menggunakan max_tokens:

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

Untuk daftar lengkap parameter yang didukung, lihat referensi API penyelesaian obrolan.

Menggunakan model di taman bermain

Gunakan model di taman bermain untuk mendapatkan gambaran tentang kemampuan model.

Segera setelah penyebaran selesai, Anda akan diarahkan ke area uji model, di mana Anda dapat mulai berinteraksi dengan penyebaran. Misalnya, Anda dapat memasukkan perintah Anda, seperti "Berapa banyak bahasa di dunia?" di taman bermain.

Troubleshooting

Jika Anda mengalami masalah saat mengikuti tutorial ini, gunakan panduan berikut untuk mengatasi masalah umum.

Kesalahan autentikasi (401/403)

• Pastikan Anda masuk ke Azure CLI. Untuk pengembangan lokal, jalankan az login sebelum menjalankan kode Anda. DefaultAzureCredential menggunakan kredensial Azure CLI Anda sebagai fallback saat tidak ada kredensial lain yang tersedia.
• Verifikasi penetapan peran. Akun Azure Anda memerlukan peran Cognitive Services User (atau lebih tinggi) pada sumber daya Foundry untuk melakukan panggilan inferensi dengan Microsoft Entra ID. Jika Anda belum menetapkan peran ini, lihat bagian Prasyarat.
• Periksa format titik akhir. URL titik akhir harus mengikuti format https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/. Verifikasi bahwa nama sumber daya cocok dengan sumber daya Foundry Anda.

Masalah penerapan

• Nama penyebaran vs. nama model. Parameter model dalam panggilan API mengacu pada nama penyebaran Anda, bukan nama model. Jika Anda menyesuaikan nama penyebaran selama pembuatan, gunakan nama tersebut alih-alih DeepSeek-R1.
• Penyebaran belum siap. Jika Anda menerima kesalahan 404, verifikasi bahwa status penyebaran menunjukkan Berhasil di portal Foundry sebelum melakukan panggilan API.

Pembatasan laju (kesalahan 429)

• Menerapkan logika pengulangan. Model penalaran menghasilkan respons lebih lama yang mengonsumsi lebih banyak token. Gunakan backoff eksponensial untuk menangani kesalahan 429 (Terlalu Banyak Permintaan).
• Pantau penggunaan token. DeepSeek-R1 konten penalaran (di dalam tag <think>) dihitung terhadap batas token Anda. Lihat kuota dan batasan untuk batas tarif saat ini.
• Kuota permintaan meningkat. Jika Anda secara konsisten mencapai batas laju, permintaan akan meningkat ke batas default.

Masalah penginstalan paket

• Python. Instal kedua paket yang diperlukan: pip install openai azure-identity. Paket azure-identity diperlukan untuk DefaultAzureCredential.
• JavaScript. Instal kedua paket yang diperlukan: npm install openai @azure/identity.
• .NET. Instal paket identitas Azure: dotnet add package Azure.Identity.

Apa yang telah Anda Pelajari

Dalam tutorial ini, Anda menyelesaikan hal-hal berikut:

• Sumber daya Foundry yang dibuat untuk menghosting model AI
• Menerapkan model penalaran DeepSeek-R1
• Melakukan panggilan API terautentikasi menggunakan Microsoft Entra ID
• Permintaan inferensi telah terkirim dan output penalaran telah diterima.
• Konten penalaran terurai dari respons model untuk memahami proses pemikiran model

Konten terkait

• Azure OpenAI di Microsoft Foundry Models v1 API
• Menggunakan model penalaran percakapan
• Bahasa pemrograman yang didukung Azure OpenAI
• Kuota dan batasan Model Foundry dari Microsoft