Platform For AI：Penyebaran Satu-Klik Model DeepSeek-V3 dan DeepSeek-R1

1. Pilih mesin inferensi

2. Pilih model dan sumber daya

Pilihan model Anda menentukan sumber daya komputasi yang diperlukan dan biaya penyebaran. Model DeepSeek tersedia dalam versi "full-version" dan "distilled", yang memiliki kebutuhan sumber daya yang sangat berbeda.

• Pengembangan dan Pengujian: Gunakan model distilled, seperti DeepSeek-R1-Distill-Qwen-7B. Model-model ini memiliki jejak sumber daya yang lebih kecil, biasanya satu GPU dengan 24 GB Memori GPU, menyebar dengan cepat, dan hemat biaya, menjadikannya ideal untuk validasi fitur cepat.

• Lingkungan Produksi: Evaluasi berdasarkan keseimbangan performa dan biaya. Model DeepSeek-R1-Distill-Qwen-32B memberikan keseimbangan yang baik antara efektivitas dan biaya. Jika Anda memerlukan performa model yang lebih tinggi, pilih model full-version. Ini memerlukan beberapa GPU kelas atas, seperti delapan GPU dengan 96 GB Memori GPU masing-masing, yang secara signifikan meningkatkan biaya.

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

Panggilan API

1. Dapatkan titik akhir layanan dan token.

   1. Di halaman Model Gallery > Task Management > Deployment Tasks, klik nama layanan yang diterapkan untuk pergi ke halaman detail layanan.

   2. Klik View Call Information untuk mendapatkan titik akhir layanan dan token.

      

2. Gunakan contoh panggilan API chat.

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

   OpenAI SDK

   Catatan:

   • Tambahkan /v1 di akhir endpoint.

   • Penyebaran yang dipercepat dengan BladeLLM tidak mendukung client.models.list(). Sebagai solusi, atur parameter model ke string kosong ("").

   Penyebaran yang dipercepat SGLang/vLLM

   from openai import OpenAI
   
   # 1. Konfigurasikan klien
   # Ganti <EAS_ENDPOINT> dan <EAS_TOKEN> dengan endpoint dan token sebenarnya dari layanan 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 endpoint dan token Anda. Kesalahan: {e}")
       
   # 3. Buat dan kirim permintaan
   stream = True
   
   chat_completion = client.chat.completions.create(
       messages=[
           {"role": "user", "content": "Halo, tolong perkenalkan dirimu."}
       ],
       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)

   Penyebaran yang dipercepat BladeLLM

   from openai import OpenAI
   
   ##### Konfigurasi API #####
   # Ganti <EAS_ENDPOINT> dengan endpoint 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,
   )
   
   # Penyebaran yang dipercepat 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": "Halo, tolong perkenalkan dirimu."}
       ],
        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

   Penyebaran yang dipercepat SGLang/vLLM

   Ganti <model_name> dengan nama model yang diperoleh dari API daftar model <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": "halo!"
           }
           ]
       }' \
       <EAS_ENDPOINT>/v1/chat/completions
   

   Python

   import json
   import requests
   
   # Ganti <EAS_ENDPOINT> dengan endpoint 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 API daftar model <EAS_ENDPOINT>/v1/models.
   model = "<model_name>"
   stream = True
   messages = [
       {"role": "user", "content": "Halo, tolong perkenalkan dirimu."},
   ]
   
   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="")
   else:
       resp = json.loads(response.text)
       print(resp["choices"][0]["message"]["content"])
   

   Penyebaran yang dipercepat BladeLLM

   curl

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

   Python

   import json
   import requests
   
   # Ganti <EAS_ENDPOINT> dengan endpoint 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": "Halo, tolong perkenalkan dirimu."},
   ]
   # Saat menggunakan BladeLLM untuk penyebaran yang dipercepat, jika Anda tidak menentukan parameter max_tokens, output akan dipotong menjadi 16 token secara default. Kami sarankan 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"])

3. Model dan kerangka kerja penyebaran yang berbeda memiliki perilaku yang berbeda saat menggunakan layanan inferensi. Temukan instruksi lebih rinci tentang panggilan API di halaman pengenalan model di Model Gallery.

Buat WebUI lokal

Gradio adalah pustaka Python yang ramah pengguna untuk dengan cepat membuat antarmuka interaktif untuk model pembelajaran mesin. Ikuti langkah-langkah berikut untuk menjalankan WebUI Gradio secara lokal.

1. Unduh Kode: Unduh kode yang sesuai berdasarkan mesin inferensi yang Anda pilih selama penyebaran. Gunakan tautan GitHub jika Anda memiliki akses jaringan stabil ke GitHub. Jika tidak, gunakan tautan OSS.

   • vLLM, SGLang: vLLM/SGLang_github, vLLM/SGLang_oss

   • BladeLLM: BladeLLM_github, BladeLLM_oss

2. Siapkan Lingkungan: Python 3.10 atau yang lebih baru diperlukan. Instal dependensi: pip install openai gradio.

3. Mulai Aplikasi Web: Jalankan perintah berikut di terminal Anda. Ganti <EAS_ENDPOINT> dan <EAS_TOKEN> dengan Endpoint dan Token layanan Anda.

   python webui_client.py --eas_endpoint "<EAS_ENDPOINT>" --eas_token "<EAS_TOKEN>"

4. Setelah aplikasi berhasil dimulai, URL lokal (biasanya http://127.0.0.1:7860) dicetak ke konsol Anda. Buka URL ini di browser Anda untuk mengakses WebUI.

Integrasi aplikasi pihak ketiga

Untuk terhubung ke Chatbox, Dify, atau Cherry Studio, lihat Integrasi Klien Pihak Ketiga.

Rincian biaya

Layanan yang diterapkan menggunakan Sumber Daya Publik ditagih per menit dari pembuatan (ketika status menjadi "Berjalan") hingga dihentikan atau dihapus, dengan tagihan diselesaikan setiap jam. Penagihan berlanjut bahkan jika layanan tidak aktif. Menghentikan layanan menghentikan penagihan.

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

Rekomendasi pengendalian biaya

• Bersihkan Segera: Setelah pengembangan dan pengujian, Hentikan atau Hapus layanan segera untuk mengendalikan biaya.

• Pilih Model yang Sesuai: Di lingkungan non-produksi, prioritaskan penggunaan model distilled yang lebih hemat biaya.

• Gunakan Sumber Daya Preemptible: Untuk tugas non-produksi, aktifkan mode preemptible selama penyebaran. Perhatikan bahwa kondisi tertentu harus dipenuhi untuk penawaran yang sukses, dan ada risiko ketidakstabilan sumber daya.

• Manfaatkan Diskon Penggunaan Jangka Panjang: Untuk layanan produksi jangka panjang, kurangi biaya dengan membeli rencana penghematan 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 dengan BladeLLM: Saat menggunakan mesin BladeLLM, jika max_tokens tidak ditentukan dalam permintaan API, output dipotong menjadi 16 token, yang dapat menyebabkan perilaku tak terduga atau kegagalan fungsi.

• Spesifikasi Panggilan API yang Salah:

  • Memasukkan system prompt dalam messages saat memanggil model seri DeepSeek-R1 dapat menyebabkan perilaku tak terduga.

  • URL permintaan API harus diakhiri dengan jalur seperti /v1/chat/completions; jika tidak, akan mengembalikan kesalahan 404.

• Ketersediaan Sumber Daya: Saat menyebar LLM, terutama versi lengkap, sumber daya GPU kelas atas di wilayah tertentu mungkin memiliki ketersediaan terbatas, yang mengarah pada kegagalan penyebaran atau waktu tunggu lama. Coba beralih ke wilayah lain.

Layanan macet dalam keadaan menunggu setelah saya klik deploy

Alasan yang mungkin termasuk:

• Sumber daya mesin tidak mencukupi di wilayah saat ini.

• Model besar, dan memuatnya memerlukan waktu lama. Untuk LLM seperti DeepSeek-R1 dan DeepSeek-V3, proses ini bisa memakan waktu 20-30 menit.

Anda bisa menunggu dan mengamati sejenak. Jika layanan masih gagal dimulai setelah periode yang lama, coba langkah-langkah berikut:

1. Pergi ke halaman Task Management > Deployment Tasks untuk melihat detail tugas penyebaran. Di pojok kanan atas halaman, klik More > More Information untuk menavigasi ke halaman detail layanan model PAI-EAS dan periksa status instans layanan.

   

2. Hentikan layanan saat ini dan beralih ke wilayah lain di pojok kiri atas konsol untuk menyebar ulang.

   Catatan

   Model ultra-besar-parameter seperti DeepSeek-R1 dan DeepSeek-V3 memerlukan setup 8-GPU untuk memulai layanan, dan ketersediaan sumber daya terbatas. Pertimbangkan untuk menyebar model distilled yang lebih kecil seperti DeepSeek-R1-Distill-Qwen-7B, untuk mana sumber daya lebih mudah tersedia.

Mengapa saya mendapatkan kesalahan 404 saat memanggil API?

Periksa apakah sufiks API OpenAI, seperti v1/chat/completions, telah ditambahkan ke URL yang Anda panggil. Untuk detailnya, lihat instruksi panggilan API di halaman beranda model.

Jika Anda menggunakan penyebaran yang dipercepat vLLM, periksa apakah parameter model dalam badan permintaan panggilan API chat diisi dengan nama model yang benar. Anda bisa mendapatkan nama model dengan memanggil endpoint /v1/models.

Permintaan terlalu lama dan menyebabkan timeout gateway

Timeout permintaan default untuk gateway yang digunakan selama penyebaran adalah 180 detik. Jika Anda perlu memperpanjang timeout ini, konfigurasikan Gateway Khusus dan ajukan tiket untuk menyesuaikan timeout permintaan untuk Gateway Khusus. Timeout maksimum yang dapat disesuaikan adalah 600 detik.

Mengapa tidak ada fitur "pencarian web"?

Fitur "pencarian web" tidak dapat diimplementasikan hanya dengan menyebar layanan model. Anda harus membangun aplikasi AI (Agent) berdasarkan layanan model.

Apa yang harus saya lakukan jika model melewati proses berpikir?

Jika Anda menyebar model DeepSeek-R1 dan menghadapi situasi di mana model kadang-kadang melewati proses berpikirnya, gunakan template obrolan terbaru dari DeepSeek yang memaksa berpikir. Untuk menggunakannya:

1. Ubah Perintah Startup.

   Seperti yang ditunjukkan pada gambar, edit konfigurasi layanan dengan mengedit JSON Configuration. Ubah bidang containers-script untuk menambahkan "--chat-template /model_dir/template_force_thinking.jinja" (Anda dapat menambahkannya setelah "--served-model-name DeepSeek-R1").

   Jika layanan sudah diterapkan, pergi ke Model Gallery > Task Management > Deployment Tasks, klik nama layanan yang diterapkan, dan kemudian klik Update Service di pojok kanan atas halaman detail untuk mengakses halaman konfigurasi yang sama.

   

2. Ubah Badan Permintaan. Dalam setiap permintaan, tambahkan {"role": "assistant", "content": "<think>\n"} di akhir array messages.

Bisakah saya menonaktifkan mode berpikir untuk DeepSeek-R1?

Seri model DeepSeek-R1 saat ini tidak mendukung menonaktifkan proses berpikir.

Bagaimana cara mengimplementasikan percakapan multi-putaran?

Layanan model itu sendiri tidak menyimpan riwayat percakapan. Aplikasi klien bertanggung jawab untuk menyimpan riwayat dan menyertakannya dalam permintaan berikutnya ke model. Berikut adalah contohnya untuk layanan yang diterapkan dengan SGLang.

curl -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: <EAS_TOKEN>" \
    -d '{
        "model": "<model_name>",
        "messages": [
         {
            "role": "user", 
            "content": "Halo"
        },
        {
            "role": "assistant",
            "content": "Halo! Senang bertemu denganmu. Apa yang bisa saya bantu?"
        },
        {
            "role": "user",
            "content": "Apa pertanyaan saya sebelumnya?"
        }
        ]
    }' \
    <EAS_ENDPOINT>/v1/chat/completions