Penerapan DeepSeek-V4 dan DeepSeek-R1 - Platform For AI - Alibaba Cloud Documentation Center

Penerapan manual model DeepSeek melibatkan tugas-tugas kompleks, seperti konfigurasi lingkungan komputasi, pemuatan model, dan optimisasi inferensi. PAI Model Gallery menyederhanakan proses ini melalui fitur penerapan satu-klik. Dalam beberapa langkah saja, Anda dapat membuat layanan model yang kompatibel dengan API OpenAI dan mengintegrasikannya ke dalam aplikasi Anda.

Arsitektur solusi

Komponen inti

Solusi ini dibangun di atas PAI dan mencakup komponen inti berikut:

Model Gallery: Berfungsi sebagai titik masuk untuk distribusi dan penerapan model. Menyediakan model DeepSeek yang telah dikonfigurasi sebelumnya beserta konfigurasi penerapannya.
Elastic Algorithm Service (EAS): Layanan inti yang meng-host penerapan dan inferensi model. Secara otomatis mengelola sumber daya komputasi dasar, seperti GPU, serta menjalankan instans layanan model.
Mesin Akselerasi Inferensi (SGLang/vLLM/BladeLLM): Mengoptimalkan kinerja inferensi model.
- SGLang/vLLM: Menyediakan antarmuka yang sepenuhnya kompatibel dengan API OpenAI, sehingga menyederhanakan migrasi aplikasi yang sudah ada.
- BladeLLM: Kerangka kerja inferensi proprietary berkinerja tinggi yang memberikan kinerja inferensi unggul dalam skenario tertentu.
API Gateway: Menyediakan saluran aman untuk mengakses layanan model. Mendukung pemanggilan layanan model melalui titik akhir layanan dan token otentikasi.

Metode penerapan

Untuk model berskala besar, selain penerapan single-node, Model Gallery juga menawarkan solusi penerapan satu-klik seperti distributed deployment dan EP+PD separation.

Sebagai contoh, DeepSeek-V4-Pro-FP8 dan DeepSeek-V4-Flash-FP8 keduanya dapat diterapkan menggunakan metode EP+PD separation.

Penerapan cepat dan validasi

Langkah 1: Terapkan layanan model

Login ke PAI console dan pilih wilayah target di pojok kiri atas. Dari panel navigasi di sebelah kiri, buka Workspaces dan pilih ruang kerja target.
Di dalam ruang kerja, buka QuickStart > Model Gallery.
Dalam daftar model, cari dan pilih model target, misalnya DeepSeek-R1-Distill-Qwen-7B, untuk membuka halaman detail model.
Klik Deploy di pojok kanan atas, lalu konfigurasikan parameter berikut.
- Inference Engine: Disarankan memilih SGLang atau vLLM.
- Deployment Resource: Pilih sumber daya publik atau sumber daya spesifikasi khusus, dan pilih spesifikasi GPU yang sesuai berdasarkan kebutuhan model.
  - Secara default, sumber daya publik digunakan dan disediakan spesifikasi yang direkomendasikan. Jika spesifikasi tidak tersedia, coba ganti wilayah.
    
    Penting
    Saat Anda menerapkan menggunakan sumber daya publik, penagihan dimulai segera setelah instans layanan menyediakan sumber daya, dengan biaya berdasarkan durasi, meskipun tidak ada panggilan. Hentikan layanan segera setelah pengujian.
  - Jika Anda memilih Resource Quota, pastikan memilih inference engine dan deployment template yang sesuai untuk tipe instans Anda. Misalnya, jika Anda menggunakan tipe instans GP7V, Anda dapat memilih SGLang untuk Inference Engine dan harus memilih Single-Node-GP7V untuk Deployment Template.
Deployment Template diatur ke Single-Node secara default. Contoh spesifikasi GPU yang direkomendasikan adalah ecs.gn7i-c16g1.4xlarge (16 vCPU, 60 GiB, 1 × NVIDIA A10), yang berbiaya sekitar CNY 11,1 per jam.
Setelah memastikan semua konfigurasi benar, klik Deploy. Sistem mulai membuat layanan.

Catatan
Untuk model besar, seperti DeepSeek-R1 versi lengkap, proses pemuatan model bisa memakan waktu 20 hingga 30 menit.
Anda dapat melihat status pekerjaan penerapan di halaman Model Gallery > Job Management > Deployment Jobs. Klik nama layanan untuk membuka halaman detail layanan. Anda juga dapat mengklik More Information di pojok kanan atas untuk melihat halaman detail layanan model di EAS.

Di halaman detail layanan, klik View Deployment Events di samping bidang Status untuk informasi lebih lanjut. Untuk mendapatkan titik akhir layanan dan token, klik View Call Information di bagian Call Information.

Langkah 2: Debugging online

Di halaman Model Gallery > Job Management > Deployment Jobs, klik nama layanan yang telah diterapkan dan beralih ke tab Online Debugging, yang mendukung Conversation Debugging dan API Debugging.

Catatan

Rekomendasi penggunaan resmi untuk seri model DeepSeek-R1 adalah sebagai berikut:

Atur temperature ke nilai antara 0,5 dan 0,7. Nilai yang direkomendasikan adalah 0,6 untuk mencegah output berulang atau tidak koheren.
Jangan tambahkan system prompt. Tempatkan semua instruksi di user prompt.
Untuk pertanyaan terkait matematika, sertakan "Please reason step by step and put the final answer in a \boxed{}." dalam prompt.

Jika hanya tersedia halaman debugging API, langkah-langkah berikut memberikan contoh menggunakan API chat dari layanan large language model (LLM):

Konfirmasi path permintaan: <EAS_ENDPOINT>/v1/chat/completions. Dalam path ini, <EAS_ENDPOINT> adalah titik akhir layanan, yang biasanya telah diisi sebelumnya.

Untuk layanan yang diterapkan dengan SGLang/vLLM, Anda dapat mengambil API yang didukung lebih lanjut dari <EAS_ENDPOINT>/openapi.json.
Buat badan permintaan.

Jika prompt-nya adalah "What is 3 + 5?", badan permintaannya diformat sebagai berikut.

Nilai parameter model adalah nama model yang diperoleh dari model list API <EAS_ENDPOINT>/v1/models. Contoh ini menggunakan DeepSeek-R1-Distill-Qwen-7B.
```
{
    "model": "DeepSeek-R1-Distill-Qwen-7B",
    "messages": [
        {
            "role": "user",
            "content": "What is 3 + 5?"
        }
    ]
}
```
Kirim permintaan.

Di tab Online Debugging, pilih POST sebagai metode HTTP dan masukkan titik akhir layanan di bidang URL, misalnya, http://<service_address>/v1/chat/completions. Di bagian Body, pilih raw dan masukkan badan permintaan JSON, termasuk bidang model, seperti DeepSeek-R1-Distill-Qwen-7B, dan messages. Klik Send Request. Area Response di sebelah kanan menampilkan kode status 200, dan respons model ditampilkan dalam format JSON di badan tanggapan.

Contoh Permintaan API BladeLLM

Penting

Saat menggunakan metode penerapan akselerasi BladeLLM, jika Anda tidak menentukan parameter max_tokens, output akan dipotong menjadi 16 token secara default. Sesuaikan parameter permintaan max_tokens sesuai kebutuhan Anda.

{
    "messages": [
        {
            "role": "user",
            "content": "What is 3 + 5?"
        }
    ],
    "max_tokens": 2000
}

Pemanggilan API

Dapatkan titik akhir layanan dan token.
1. Di halaman Model Gallery > Job Management > Deployment Jobs, klik nama layanan yang telah diterapkan untuk membuka halaman detail layanan.
2. Klik View Call Information untuk mendapatkan titik akhir layanan dan token.

Contoh berikut menunjukkan cara melakukan pemanggilan API chat.

Ganti <EAS_ENDPOINT> dengan titik akhir layanan dan <EAS_TOKEN> dengan token layanan.

OpenAI SDK

Catatan:

Tambahkan /v1 di akhir titik akhir.
Penerapan akselerasi BladeLLM tidak mendukung client.models.list(). Sebagai solusi alternatif, atur parameter model ke string kosong ("").

SGLang/vLLM

from openai import OpenAI
# 1. Konfigurasikan client
# Ganti <EAS_ENDPOINT> dan <EAS_TOKEN> dengan titik akhir dan token layanan aktual Anda.
openai_api_key = "<EAS_TOKEN>"
openai_api_base = "<EAS_ENDPOINT>/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)
# 2. Dapatkan nama model 
try:
    model = client.models.list().data[0].id
    print(model)
except Exception as e:
    print(f"Gagal mendapatkan daftar model. Periksa titik akhir dan token. Error: {e}")
# 3. Buat dan kirim permintaan
stream = True
chat_completion = client.chat.completions.create(
    messages=[
        {"role": "user", "content": "Hello, please introduce yourself."}
    ],
    model=model,
    max_tokens=2048,
    stream=stream,
)
if stream:
    for chunk in chat_completion:
        print(chunk.choices[0].delta.content, end="")
else:
    result = chat_completion.choices[0].message.content
    print(result)

BladeLLM

from openai import OpenAI
##### Konfigurasi API #####
# Ganti <EAS_ENDPOINT> dengan titik akhir layanan yang diterapkan dan <EAS_TOKEN> dengan token layanan yang diterapkan.
openai_api_key = "<EAS_TOKEN>"
openai_api_base = "<EAS_ENDPOINT>/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)
# Penerapan akselerasi BladeLLM saat ini tidak mendukung penggunaan client.models.list() untuk mendapatkan nama model. Anda dapat mengatur nilai model ke "" untuk kompatibilitas.
model=""
stream = True
chat_completion = client.chat.completions.create(
    messages=[
              {"role": "user", "content": "Hello, please introduce yourself."}
    ],
     model=model,
     max_tokens=2048,
     stream=stream,
    )
if stream:
    for chunk in chat_completion:
        print(chunk.choices[0].delta.content, end="")
else:
    result = chat_completion.choices[0].message.content
    print(result)

HTTP

SGLang/vLLM

Ganti <model_name> dengan nama model yang diperoleh dari model list API <EAS_ENDPOINT>/v1/models.

curl

curl -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: <EAS_TOKEN>" \
    -d '{
        "model": "<model_name>",
        "messages": [
        {
            "role": "user",
            "content": "hello!"
        }
        ]
    }' \
    <EAS_ENDPOINT>/v1/chat/completions

Python

import json
import requests
# Ganti <EAS_ENDPOINT> dengan titik akhir layanan yang diterapkan dan <EAS_TOKEN> dengan token layanan yang diterapkan.
EAS_ENDPOINT = "<EAS_ENDPOINT>"
EAS_TOKEN = "<EAS_TOKEN>"
url = f"{EAS_ENDPOINT}/v1/chat/completions"
headers = {
    "Content-Type": "application/json",
    "Authorization": EAS_TOKEN,
}
# Ganti <model_name> dengan nama model yang diperoleh dari model list API <EAS_ENDPOINT>/v1/models.
model = "<model_name>"
stream = True
messages = [
    {"role": "user", "content": "Hello, please introduce yourself."},
]
req = {
    "messages": messages,
    "stream": stream,
    "temperature": 0.6,
    "top_p": 0.5,
    "top_k": 10,
    "max_tokens": 300,
    "model": model,
}
response = requests.post(
    url,
    json=req,
    headers=headers,
    stream=stream,
)
if stream:
    for chunk in response.iter_lines(chunk_size=8192, decode_unicode=False):
        msg = chunk.decode("utf-8")
        if msg.startswith("data"):
            info = msg[6:]
            if info == "[DONE]":
                break
            else:
                resp = json.loads(info)
                print(resp["choices"][0]["delta"]["content"], end="", flush=True)
else:
    resp = json.loads(response.text)
    print(resp["choices"][0]["message"]["content"])

BladeLLM

curl

curl -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: <EAS_TOKEN>" \
    -d '{
        "messages": [
        {
            "role": "user",
            "content": "hello!"
        }
        ]
    }' \
    <EAS_ENDPOINT>/v1/chat/completions

Python

import json
import requests
# Ganti <EAS_ENDPOINT> dengan titik akhir layanan yang diterapkan dan <EAS_TOKEN> dengan token layanan yang diterapkan.
EAS_ENDPOINT = "<EAS_ENDPOINT>"
EAS_TOKEN = "<EAS_TOKEN>"
url = f"{EAS_ENDPOINT}/v1/chat/completions"
headers = {
    "Content-Type": "application/json",
    "Authorization": EAS_TOKEN,
}
stream = True
messages = [
    {"role": "user", "content": "Hello, please introduce yourself."},
]
# Saat Anda menggunakan BladeLLM untuk penerapan akselerasi, jika Anda tidak menentukan parameter max_tokens, output akan dipotong menjadi 16 token secara default. Kami menyarankan Anda menyesuaikan parameter permintaan max_tokens sesuai kebutuhan.
req = {
    "messages": messages,
    "stream": stream,
    "temperature": 0.6,
    "top_p": 0.5,
    "top_k": 10,
    "max_tokens": 300,
}
response = requests.post(
    url,
    json=req,
    headers=headers,
    stream=stream,
)
if stream:
    for chunk in response.iter_lines(chunk_size=8192, decode_unicode=False):
        msg = chunk.decode("utf-8")
        if msg.startswith("data"):
            info = msg[6:]
            if info == "[DONE]":
                break
            else:
                resp = json.loads(info)
                if resp["choices"][0]["delta"].get("content") is not None:
                      print(resp["choices"][0]["delta"]["content"], end="", flush=True)
else:
    resp = json.loads(response.text)
    print(resp["choices"][0]["message"]["content"])

Karena model dan framework penerapan yang berbeda memiliki perilaku berbeda, Anda harus merujuk pada petunjuk pemanggilan API terperinci di halaman pengenalan model di Model Gallery.

Sebagai contoh, halaman pengenalan model DeepSeek-R1-Distill-Qwen-7B di Model Gallery menentukan kebutuhan sumber daya untuk penerapan akselerasi BladeLLM. Penerapan ini memerlukan memori GPU 24 GB dan hanya mendukung keluarga instans ecs.gn7 ke atas. Halaman tersebut juga menyatakan bahwa model ini kompatibel dengan endpoint v1/completions dan v1/chat/completions OpenAI serta menyediakan contoh pemanggilan menggunakan perintah curl dan skrip Python.

Integrasi pihak ketiga

Untuk menghubungkan ke Chatbox, Dify, atau Cherry Studio, lihat Integrate third-party clients.

UI Web lokal

Lihat Membangun UI Web Lokal Menggunakan Gradio.

Pembersihan sumber daya

Untuk instans yang diterapkan menggunakan sumber daya publik, penagihan dihitung berdasarkan durasi penggunaan dan dimulai segera setelah sumber daya disediakan. Penggunaan kurang dari satu jam dikenai biaya per menit.

Buka halaman Job Management > Deployment Jobs.
Temukan layanan yang ingin Anda hentikan dan klik Stop atau Delete di kolom Actions.
- Stop: Instans layanan dilepas dan penagihan dihentikan. Konfigurasi layanan tetap disimpan, dan Anda dapat menjalankan kembali layanan nanti.
- Delete: Baik konfigurasi layanan maupun instans dihapus secara permanen.

Pemilihan model dan sumber daya

Pilihan model Anda menentukan sumber daya komputasi yang diperlukan dan biaya penerapan. Model DeepSeek tersedia dalam varian "versi lengkap" dan "versi distilled", yang memiliki kebutuhan sumber daya sangat berbeda.

Pengembangan dan pengujian: Kami menyarankan Anda menggunakan model versi distilled, seperti DeepSeek-R1-Distill-Qwen-7B. Model-model ini memiliki jejak sumber daya lebih kecil, biasanya satu GPU dengan memori GPU 24 GB, diterapkan dengan cepat, dan hemat biaya, sehingga ideal untuk validasi fitur cepat.
Lingkungan produksi: Evaluasi berdasarkan keseimbangan antara kinerja dan biaya. Model DeepSeek-R1-Distill-Qwen-32B memberikan keseimbangan baik antara efektivitas dan biaya. Jika Anda memerlukan kinerja model lebih tinggi, pilih model versi lengkap. Ini memerlukan beberapa GPU high-end, seperti delapan GPU dengan memori GPU 96 GB masing-masing, yang secara signifikan meningkatkan biaya.

Tabel berikut mencantumkan konfigurasi minimum untuk berbagai versi model dan jumlah maksimum token yang didukung oleh berbagai tipe instans dan mesin inferensi.

Model versi lengkap

Model	Metode penerapan	Token maks		Konfigurasi minimum
Model	Metode penerapan	SGLang	vLLM	Konfigurasi minimum
DeepSeek-V4-Pro	Single-node/Distributed	1M	1M	Single-node dengan 8 × H20-3e (8 × 141 GB memori GPU)
DeepSeek-V4-Flash	Single-node	1M	1M	Single-node dengan 8 × H20-3e (8 × 141 GB memori GPU)
DeepSeek-V4-Pro-FP8	Single-node/PD separation	1M	/	Single-node dengan 8 × H20-3e (8 × 141 GB memori GPU)
DeepSeek-V4-Flash-FP8	Single-node/PD separation	1M	/	Single-node dengan 4 × H20-3e (4 × 141 GB memori GPU)
DeepSeek-V3	Single-node - NVIDIA GPU	56.000	65.536	Single-node 8 × GU120 (8 × 96 GB memori GPU)
	Single-node - Tipe instans GP7V	56.000	16.384
	Distributed - PAI Lingjun Intelligent Computing Service	163.840	163.840
DeepSeek-R1	Single-node - NVIDIA GPU	56.000	65.536	Single-node 8 × GU120 (8 × 96 GB memori GPU)
	Single-node - Tipe instans GP7V	56.000	16.384
	Distributed - PAI Lingjun Intelligent Computing Service	163.840	163.840

Catatan tipe instans untuk penerapan single-node:

NVIDIA GPU:
- ml.gu8v.c192m1024.8-gu120 dan ecs.gn8v-8x.48xlarge tersedia sebagai sumber daya publik, tetapi stoknya mungkin terbatas.
- ecs.ebmgn8v.48xlarge tidak dapat digunakan sebagai sumber daya publik. Anda harus membeli sumber daya EAS khusus.
Tipe instans GP7V: ml.gp7vf.16.40xlarge adalah sumber daya publik dan hanya dapat digunakan sebagai instans preemptible. Jika sumber daya GPU NVIDIA langka, alihkan ke wilayah China (Ulanqab) untuk menemukan sumber daya tipe instans GP7V. Anda harus mengonfigurasi VPC saat menerapkan.

Catatan untuk tipe instans penerapan terdistribusi (direkomendasikan saat diperlukan performa tinggi):

Penerapan distributed bergantung pada jaringan berkecepatan tinggi dan harus menggunakan PAI Lingjun Intelligent Computing Service, yang menyediakan daya komputasi heterogen elastis berkinerja tinggi. Anda juga harus mengonfigurasi VPC selama penerapan. Untuk menggunakan PAI Lingjun Intelligent Computing Service, alihkan wilayah ke China (Ulanqab).

Sumber daya publik Lingjun:
- ml.gu7xf.8xlarge-gu108: Memerlukan empat mesin untuk penerapan single-instance dan hanya dapat digunakan sebagai instans preemptible.
- Tipe instans GP7V: Memerlukan dua mesin untuk penerapan single-instance.
Sumber daya prabayar Lingjun: Anda harus ditambahkan ke daftar putih untuk menggunakan sumber daya ini. Hubungi manajer penjualan Anda atau kirim tiket untuk konsultasi.

Model versi distilled

Model	Token maks			Konfigurasi minimum
Model	SGLang	vLLM	BladeLLM	Konfigurasi minimum
DeepSeek-R1-Distill-Qwen-1.5B	131.072	131.072	131.072	1 × GPU A10 (24 GB memori GPU)
DeepSeek-R1-Distill-Qwen-7B	131.072	32.768	131.072	1 × GPU A10 (24 GB memori GPU)
DeepSeek-R1-Distill-Llama-8B	131.072	32.768	131.072	1 × GPU A10 (24 GB memori GPU)
DeepSeek-R1-Distill-Qwen-14B	131.072	32.768	131.072	1 × GPU L (48 GB memori GPU)
DeepSeek-R1-Distill-Qwen-32B	131.072	32.768	131.072	2 × GPU L (2 × 48 GB memori GPU)
DeepSeek-R1-Distill-Llama-70B	131.072	32.768	131.072	2 × GU120 (2 × 96 GB memori GPU)

Model yang dioptimalkan PAI

Model Gallery menyediakan penerapan satu-klik untuk model DeepSeek terkait yang dioptimalkan PAI berikut:

DeepSeek-R1-PAI-optimized
DeepSeek-R1-0528-PAI-optimized
DeepSeek-V3-0324-PAI-optimized

Biaya dan risiko

Rincian biaya

Untuk layanan yang menggunakan sumber daya publik, penagihan dihitung per menit, mulai dari saat instans disediakan hingga dihentikan atau dihapus. Tagihan diselesaikan per jam. Biaya terus berjalan meskipun layanan menganggur. Menghentikan layanan akan menghentikan penagihan.

Untuk informasi lebih lanjut, lihat Billing of Elastic Algorithm Service (EAS).

Kontrol biaya

Lakukan pembersihan segera: Setelah pengembangan dan pengujian, segera hentikan atau hapus layanan untuk mengendalikan biaya secara efektif.
Pilih model yang sesuai: Di lingkungan non-produksi, prioritaskan model versi distilled yang lebih hemat biaya.
Gunakan instans preemptible: Untuk tugas non-produksi, Anda dapat mengaktifkan mode preemptible selama penerapan. Perhatikan bahwa kondisi tertentu harus dipenuhi agar penawaran berhasil, dan terdapat risiko ketidakstabilan sumber daya.
Discount penggunaan jangka panjang: Untuk layanan produksi yang berjalan lama, Anda dapat mengurangi biaya dengan membeli savings plan atau sumber daya prabayar.

Risiko utama

Biaya tak terduga: Lupa menghentikan layanan mengakibatkan penagihan terus-menerus. Selalu bersihkan sumber daya segera setelah digunakan.
Pemotongan output BladeLLM: Saat menggunakan mesin BladeLLM, jika parameter max_tokens tidak ditentukan dalam permintaan API, output akan dipotong menjadi 16 token, yang mungkin mencegah fitur berfungsi sebagaimana mestinya.
Penggunaan API salah:
- Saat memanggil model seri DeepSeek-R1, menyertakan prompt system dalam messages dapat menyebabkan perilaku tak terduga.
- URL permintaan API harus diakhiri dengan path seperti /v1/chat/completions. Jika tidak, error 404 akan dikembalikan.
Stok sumber daya: Stok terbatas sumber daya GPU high-end di wilayah tertentu dapat menyebabkan kegagalan penerapan atau waktu tunggu lama. Anda dapat mencoba beralih ke wilayah lain.

FAQ penerapan model

Memilih mesin inferensi

Disarankan: SGLang. Memberikan kinerja tinggi sekaligus sepenuhnya kompatibel dengan standar API OpenAI, sehingga sangat cocok untuk ekosistem aplikasi utama. Di sebagian besar skenario, mendukung panjang konteks maksimum lebih panjang daripada vLLM.
Alternatif: vLLM. Sebagai framework populer di industri, juga menawarkan kompatibilitas API yang sangat baik.
Skenario khusus BladeLLM: Gunakan BladeLLM, framework inferensi berkinerja tinggi yang dikembangkan internal oleh Alibaba Cloud PAI, hanya jika Anda memerlukan kinerja inferensi lebih tinggi dan dapat menerima perbedaan API dari standar OpenAI, seperti tidak mendukung client.models.list() dan perilaku pemotongan default untuk parameter max_tokens.

Layanan macet menunggu

Kemungkinan penyebab:

Sumber daya mesin tidak mencukupi di wilayah saat ini.
Model berukuran besar, dan pemuatan model memakan waktu lama. Untuk model besar seperti DeepSeek-R1 dan DeepSeek-V3, ini dapat memakan waktu 20 hingga 30 menit.

Anda dapat menunggu beberapa saat. Jika layanan masih gagal memulai setelah waktu yang lama, kami sarankan Anda mencoba langkah-langkah berikut:

Buka halaman Job Management > Deployment Jobs untuk melihat detail pekerjaan penerapan. Di pojok kanan atas, klik More > More Information untuk membuka halaman detail layanan model PAI-EAS dan memeriksa status instans layanan.

Jika kolom Instance Status menampilkan Insufficient Inventory, artinya instans tidak dapat dijadwalkan karena kekurangan sumber daya.
Hentikan layanan saat ini, lalu alihkan ke wilayah lain di pojok kiri atas konsol untuk menerapkan ulang layanan.

Catatan
Untuk model parameter sangat besar seperti DeepSeek-R1 dan DeepSeek-V3, diperlukan 8 GPU untuk memulai layanan (stok sumber daya terbatas). Anda dapat memilih untuk menerapkan model distilled yang lebih kecil seperti DeepSeek-R1-Distill-Qwen-7B (stok sumber daya melimpah).

FAQ pemanggilan model

Pemanggilan API mengembalikan 404

Periksa apakah sufiks API OpenAI, seperti v1/chat/completions, telah ditambahkan ke URL. Untuk informasi lebih lanjut, rujuk petunjuk pemanggilan API di halaman pengenalan model.

Jika Anda menggunakan penerapan akselerasi vLLM, periksa bahwa parameter model dalam badan permintaan API percakapan diatur ke nama model yang benar. Anda dapat memperoleh nama model dari v1/models.

Waktu permintaan habis

Timeout permintaan gateway default adalah 180 detik. Untuk memperpanjangnya, konfigurasikan Dedicated Gateway dan kirim tiket untuk menyesuaikan timeout. Maksimum adalah 600 detik.

Tidak ada fitur "web search"

Fitur "web search" tidak diaktifkan hanya dengan menerapkan layanan model; fitur ini memerlukan pembuatan aplikasi AI terpisah (Agent) di atas layanan tersebut.

Model melewatkan proses berpikir

Jika model DeepSeek-R1 terkadang melewatkan proses berpikir, gunakan templat chat terbaru dari DeepSeek yang memaksa berpikir:

Ubah perintah startup.

Dalam konfigurasi layanan, edit konfigurasi JSON. Ubah bidang containers-script untuk menambahkan --chat-template /model_dir/template_force_thinking.jinja, yang dapat ditambahkan setelah --served-model-name DeepSeek-R1.

Untuk layanan yang sudah diterapkan, buka Model Gallery > Job Management > Deployment Jobs, klik nama layanan yang diterapkan, lalu klik Update service di pojok kanan atas untuk membuka halaman konfigurasi.
Ubah badan permintaan. Dalam setiap permintaan, tambahkan {"role": "assistant", "content": "<think>\n"} di akhir pesan.

Menonaktifkan mode berpikir

Model seri DeepSeek-R1 tidak mendukung penonaktifan proses berpikir.

Percakapan multi-putaran

Layanan model tidak menyimpan riwayat percakapan. Aplikasi klien harus menyimpan riwayat dan menyertakannya dalam permintaan berikutnya. Contoh berikut menunjukkan percakapan multi-putaran dengan layanan yang diterapkan menggunakan SGLang.

curl

curl -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: <EAS_TOKEN>" \
    -d '{
        "model": "<model_name>",
        "messages": [
         {
            "role": "user", 
            "content": "Hello"
        },
        {
            "role": "assistant",
            "content": "Hello! I''m glad to see you. What can I help you with?"
        },
        {
            "role": "user",
            "content": "What was my previous question?"
        }
        ]
    }' \
    <EAS_ENDPOINT>/v1/chat/completions

Platform For AI:Penerapan DeepSeek-V4 dan DeepSeek-R1

Arsitektur solusi

Komponen inti

Metode penerapan

Penerapan cepat dan validasi

Langkah 1: Terapkan layanan model

Langkah 2: Debugging online

Pemanggilan API

OpenAI SDK

SGLang/vLLM

BladeLLM

HTTP

SGLang/vLLM

BladeLLM

Integrasi pihak ketiga

UI Web lokal

Pembersihan sumber daya

Pemilihan model dan sumber daya

Model versi lengkap

Model versi distilled

Model yang dioptimalkan PAI

Biaya dan risiko

Rincian biaya

Kontrol biaya

Risiko utama

FAQ penerapan model

Memilih mesin inferensi

Layanan macet menunggu

FAQ pemanggilan model

Pemanggilan API mengembalikan 404

Waktu permintaan habis

Tidak ada fitur "web search"

Model melewatkan proses berpikir

Menonaktifkan mode berpikir

Percakapan multi-putaran

Dokumentasi terkait