Cara Menjalankan Deepseek V3 0324 Secara Lokal (dengan Langkah-Langkah)

Selamat datang! Dalam tutorial ini, saya akan memandu Anda menjalankan DeepSeek V3 0324, model bahasa 671 miliar parameter yang sangat kuat, di mesin lokal Anda. Kita akan membahas semuanya mulai dari persiapan hingga menjalankan perintah pertama Anda menggunakan teknik kuantisasi dinamis yang menyeimbangkan akurasi model dengan kebutuhan memori.

DeepSeek V3 0324: Seberapa Bagus?

Pembaruan DeepSeek pada Maret 2024 membawa peningkatan kinerja yang signifikan dibandingkan model V3 sebelumnya:

• Skor MMLU-Pro meningkat sebesar +5,3% (menjadi 81,2%)
• Skor AIME meningkat sebesar +19,8%
• Skor LiveCodeBench meningkat sebesar +10,0%
• Skor GPQA meningkat sebesar +9,3%

Model aslinya memiliki 671 miliar parameter yang sangat besar, yang berarti kita memerlukan teknik kuantisasi yang efisien untuk menjalankannya pada perangkat keras konsumen.

Berikut adalah opsi kuantisasi yang tersedia untuk menyeimbangkan ruang disk dan akurasi:

Model float8 asli membutuhkan 715GB, jadi versi terkuantisasi ini menawarkan penghematan ruang yang signifikan!

Tutorial Langkah demi Langkah: Menjalankan DeepSeek V3 0324 di llama.cpp

Sebelum kita mulai, mari kita pahami pengaturan optimal untuk DeepSeek V3 0324:

• Suhu: 0.3 (gunakan 0.0 untuk tugas pengkodean)
• Min_P: 0.01 (membantu menyaring token yang tidak mungkin)
• Templat obrolan: <｜User｜>PROMPT_ANDA<｜Assistant｜>
• Untuk kuantisasi cache KV, gunakan 8bit (bukan 4bit) untuk kinerja yang lebih baik

Langkah 1: Siapkan llama.cpp

Pertama, kita perlu mendapatkan dan mengkompilasi llama.cpp:

# Perbarui paket dan instal dependensi yang diperlukan
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

# Klon repositori llama.cpp
git clone <https://github.com/ggml-org/llama.cpp>

# Bangun dengan dukungan CUDA untuk GPU (gunakan -DGGML_CUDA=OFF untuk CPU-only)
# Catatan: membangun dengan CUDA mungkin membutuhkan waktu sekitar 5 menit
cmake llama.cpp -B llama.cpp/build \\\\
  -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON

# Bangun alat yang diperlukan
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split

# Salin alat yang dibangun untuk akses mudah
cp llama.cpp/build/bin/llama-* llama.cpp/

Langkah 2: Unduh Model Terkuantisasi

Instal paket Python yang diperlukan dan unduh model:

pip install huggingface_hub hf_transfer

# Siapkan lingkungan untuk unduhan yang lebih cepat
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"

# Unduh model (di sini kita menggunakan kuantisasi dinamis 2.7bit untuk keseimbangan)
from huggingface_hub import snapshot_download
snapshot_download(
  repo_id = "unsloth/DeepSeek-V3-0324-GGUF",
  local_dir = "unsloth/DeepSeek-V3-0324-GGUF",
  allow_patterns = ["*UD-Q2_K_XL*"],  # Dinamis 2.7bit (230GB)
  # Gunakan "*UD-IQ_S*" untuk Dinamis 1.78bit (151GB) jika ruang terbatas
)

Langkah 3: Jalankan Prompt Uji

Mari kita uji model dengan prompt yang memintanya untuk membuat game Flappy Bird:

./llama.cpp/llama-cli \\\\
  --model unsloth/DeepSeek-V3-0324-GGUF/UD-Q2_K_XL/DeepSeek-V3-0324-UD-Q2_K_XL-00001-of-00006.gguf \\\\
  --cache-type-k q8_0 \\\\
  --threads 20 \\\\
  --n-gpu-layers 2 \\\\
  -no-cnv \\\\
  --prio 3 \\\\
  --temp 0.3 \\\\
  --min_p 0.01 \\\\
  --ctx-size 4096 \\\\
  --seed 3407 \\\\
  --prompt "<｜User｜>Buat game Flappy Bird di Python. Anda harus menyertakan hal-hal ini:
1. Anda harus menggunakan pygame.
2. Warna latar belakang harus dipilih secara acak dan merupakan warna terang. Mulailah dengan warna biru muda.
3. Menekan SPACE beberapa kali akan mempercepat burung.
4. Bentuk burung harus dipilih secara acak sebagai persegi, lingkaran, atau segitiga. Warnanya harus dipilih secara acak sebagai warna gelap.
5. Tempatkan di bagian bawah beberapa tanah berwarna coklat tua atau kuning yang dipilih secara acak.
6. Buat skor yang ditampilkan di sisi kanan atas. Tingkatkan jika Anda melewati pipa dan tidak mengenainya.
7. Buat pipa yang berjarak acak dengan ruang yang cukup. Warnai secara acak sebagai hijau tua atau coklat muda atau warna abu-abu tua.
8. Saat Anda kalah, tunjukkan skor terbaik. Buat teks di dalam layar. Menekan q atau Esc akan keluar dari game. Memulai ulang adalah menekan SPACE lagi.
Game terakhir harus berada di dalam bagian markdown di Python. Periksa kode Anda untuk kesalahan dan perbaiki sebelum bagian markdown terakhir.<｜Assistant｜>"

Berikut adalah penjelasan dari parameternya:

• -model: Jalur ke file model
• -cache-type-k q8_0: Menggunakan kuantisasi 8-bit untuk cache KV
• -threads 20: Jumlah thread CPU (sesuaikan berdasarkan CPU Anda)
• -n-gpu-layers 2: Jumlah lapisan yang akan dialihkan ke GPU (sesuaikan jika Anda memiliki masalah memori)
• no-cnv: Menonaktifkan konvolusi karena alasan kinerja
• -prio 3: Pengaturan prioritas
• -temp 0.3: Pengaturan suhu (gunakan 0.0 untuk pengkodean deterministik)
• -min_p 0.01: Probabilitas minimum untuk pengambilan sampel token
• -ctx-size 4096: Ukuran jendela konteks
• -seed 3407: Seed acak untuk reproduktibilitas

Menguji Deepseek V3 0324 dengan "Tantangan Heptagon"

Anda dapat lebih lanjut menguji kemampuan model Anda dengan menjalankan "Tantangan Heptagon," yang meminta model untuk membuat simulasi fisika kompleks dengan bola yang memantul di dalam heptagon yang berputar:

./llama.cpp/llama-cli \\\\
  --model unsloth/DeepSeek-V3-0324-GGUF/UD-Q2_K_XL/DeepSeek-V3-0324-UD-Q2_K_XL-00001-of-00006.gguf \\\\
  --cache-type-k q8_0 \\\\
  --threads 20 \\\\
  --n-gpu-layers 2 \\\\
  -no-cnv \\\\
  --prio 3 \\\\
  --temp 0.3 \\\\
  --min_p 0.01 \\\\
  --ctx-size 4096 \\\\
  --seed 3407 \\\\
  --prompt "<｜User｜>Tulis program Python yang menunjukkan 20 bola memantul di dalam heptagon yang berputar:
- Semua bola memiliki jari-jari yang sama.
- Semua bola memiliki angka di atasnya dari 1 hingga 20.
- Semua bola jatuh dari pusat heptagon saat memulai.
- Warnanya adalah: #f8b862, #f6ad49, #f39800, #f08300, #ec6d51, #ee7948, #ed6d3d, #ec6800, #ec6800, #ee7800, #eb6238, #ea5506, #ea5506, #eb6101, #e49e61, #e45e32, #e17b34, #dd7a56, #db8449, #d66a35
- Bola harus dipengaruhi oleh gravitasi dan gesekan, dan mereka harus memantul dari dinding yang berputar secara realistis. Harus ada juga tabrakan antar bola.
- Bahan dari semua bola menentukan bahwa tinggi pantulan dampaknya tidak akan melebihi jari-jari heptagon, tetapi lebih tinggi dari jari-jari bola.
- Semua bola berputar dengan gesekan, angka pada bola dapat digunakan untuk menunjukkan putaran bola.
- Heptagon berputar di sekitar pusatnya, dan kecepatan putarannya adalah 360 derajat per 5 detik.
- Ukuran heptagon harus cukup besar untuk menampung semua bola.
- Jangan gunakan pustaka pygame; implementasikan algoritma deteksi tabrakan dan respons tabrakan dll. sendiri. Pustaka Python berikut diizinkan: tkinter, math, numpy, dataclasses, typing, sys.
- Semua kode harus dimasukkan ke dalam satu file Python.<｜Assistant｜>"

Mengoptimalkan Kinerja Deepseek V3 0324

Flash Attention: Untuk decoding yang lebih cepat, gunakan Flash Attention saat mengkompilasi llama.cpp:

-DGGML_CUDA_FA_ALL_QUANTS=ON

Arsitektur CUDA: Atur arsitektur CUDA spesifik Anda untuk mengurangi waktu kompilasi:

-DCMAKE_CUDA_ARCHITECTURES="80"  # Sesuaikan untuk GPU Anda

Menyesuaikan Parameter:

• Jika Anda mengalami masalah kehabisan memori, coba kurangi -n-gpu-layers
• Untuk inferensi hanya CPU, hapus parameter -n-gpu-layers
• Sesuaikan -threads berdasarkan core CPU Anda

Anda sekarang memiliki DeepSeek V3 0324 yang berjalan secara lokal! Untuk rekap:

1. Kami menyiapkan llama.cpp dengan dukungan CUDA
2. Mengunduh versi terkuantisasi dari model (kuantisasi dinamis 2.7bit)
3. Menjalankan prompt uji untuk memverifikasi kemampuan model
4. Belajar tentang pengaturan optimal dan tips kinerja

Kuantisasi dinamis 2.7bit memberikan keseimbangan yang sangat baik antara ruang disk (231GB) dan akurasi model, memungkinkan Anda menjalankan model 671B parameter ini secara efisien di perangkat keras Anda sendiri.

Jangan ragu untuk bereksperimen dengan prompt dan parameter yang berbeda untuk mendapatkan hasil maksimal dari model yang kuat ini!

Menguji DeepSeek API dengan Apidog

Jika Anda mengembangkan aplikasi yang menggunakan DeepSeek melalui API-nya daripada menjalankannya secara lokal, Apidog menyediakan alat yang ampuh untuk pengembangan, pengujian, dan debugging API.

Menyiapkan Apidog untuk Pengujian DeepSeek API

Langkah 1: Unduh dan Instal Apidog

1. Kunjungi https://apidog.com/download/ untuk mengunduh klien Apidog untuk sistem operasi Anda.

2. Instal dan luncurkan Apidog, lalu buat akun atau masuk dengan Google/Github.

3. Saat diminta, pilih peran Anda (mis., "Pengembang Fullstack") dan mode kerja pilihan (mis., "Desain API terlebih dahulu").

Langkah 2: Buat Proyek API Baru untuk DeepSeek

1. Buat proyek HTTP baru di Apidog untuk pengujian DeepSeek API Anda.
2. Tambahkan titik akhir DeepSeek API Anda ke proyek.

Debugging Respons Streaming dari DeepSeek

DeepSeek dan banyak model AI lainnya menggunakan Server-Sent Events (SSE) untuk respons streaming. Apidog (versi 2.6.49 atau lebih tinggi) memiliki dukungan bawaan untuk debugging SSE:

1. Buat dan konfigurasi titik akhir DeepSeek API Anda di Apidog.
2. Kirim permintaan ke DeepSeek API Anda.
3. Jika respons menyertakan header Content-Type: text/event-stream, Apidog secara otomatis memprosesnya sebagai peristiwa SSE.
4. Lihat respons streaming waktu nyata di tampilan Timeline panel respons.

Apidog memiliki dukungan bawaan untuk format model AI populer, termasuk:

• Format Kompatibel API OpenAI
• Format Kompatibel API Gemini
• Format Kompatibel API Claude

Khusus untuk DeepSeek, Apidog dapat menampilkan proses berpikir model di timeline, memberikan wawasan tentang penalaran AI.

Menyesuaikan Penanganan Respons SSE untuk DeepSeek

Jika format respons DeepSeek tidak sesuai dengan aturan pengenalan bawaan Apidog, Anda dapat:

Konfigurasikan aturan ekstraksi JSONPath untuk respons SSE berformat JSON:

• Untuk respons seperti: data: {"choices":[{"index":0,"message":{"role":"assistant","content":"H"}}]}
• Gunakan JSONPath: $.choices[0].message.content

Gunakan skrip pasca-pemroses untuk pesan SSE non-JSON:

• Tulis skrip khusus untuk menangani format data
• Proses pesan sesuai dengan kebutuhan spesifik Anda

Membuat Pengujian Otomatis untuk DeepSeek API

Setelah Anda menyiapkan titik akhir DeepSeek API Anda, Anda dapat membuat pengujian otomatis di Apidog untuk memastikan fungsinya dengan benar:

1. Buat skenario pengujian untuk berbagai jenis prompt di modul Tests.
2. Tambahkan validasi dan pernyataan untuk memverifikasi struktur dan konten respons.
3. Konfigurasikan skenario pengujian untuk dijalankan dengan lingkungan yang berbeda (mis., pengembangan, produksi).
4. Siapkan batch run untuk menguji beberapa skenario sekaligus.

Untuk integrasi CI/CD, Apidog CLI memungkinkan Anda menjalankan pengujian ini sebagai bagian dari pipeline Anda:

# Instal Apidog CLI
npm install -g apidog-cli

# Jalankan skenario pengujian
apidog run test-scenario -c <collection-id> -e <environment-id> -k <api-key>

Anda dapat membaca lebih lanjut tentang cara kerja apidog-cli di Dokumentasi Resmi.

Pengujian Kinerja DeepSeek API

Apidog juga menawarkan kemampuan pengujian kinerja untuk mengevaluasi bagaimana DeepSeek API Anda berkinerja di bawah beban:

Buat skenario pengujian yang menyertakan panggilan ke DeepSeek API Anda.

Konfigurasikan pengaturan pengujian kinerja:

• Atur jumlah pengguna virtual (hingga 100)
• Tentukan durasi pengujian
• Konfigurasikan durasi ramp-up untuk mensimulasikan peningkatan pengguna secara bertahap

Jalankan pengujian kinerja untuk melihat metrik utama seperti:

• Throughput rata-rata
• Waktu respons rata-rata
• Waktu respons maksimum/minimum
• Tingkat kesalahan

Ini sangat berguna untuk memahami bagaimana penerapan DeepSeek Anda menangani beberapa permintaan bersamaan.

Kesimpulan

Anda sekarang memiliki DeepSeek V3 0324 yang berjalan secara lokal dan pengetahuan untuk menguji DeepSeek API secara efektif menggunakan Apidog! Untuk rekap:

• Kami menyiapkan llama.cpp dengan dukungan CUDA
• Mengunduh versi terkuantisasi dari model (kuantisasi dinamis 2.7bit)
• Menjalankan prompt uji untuk memverifikasi kemampuan model
• Belajar cara menggunakan Apidog untuk menguji dan men-debug DeepSeek API
• Menjelajahi tips optimasi kinerja untuk penerapan lokal dan pengujian API

Kuantisasi dinamis 2.7bit memberikan keseimbangan yang sangat baik antara ruang disk (231GB) dan akurasi model, memungkinkan Anda menjalankan model 671B parameter ini secara efisien di perangkat keras Anda sendiri. Sementara itu, Apidog memberi Anda alat yang ampuh untuk mengembangkan, menguji, dan men-debug implementasi DeepSeek API, terutama dengan kemampuan debugging SSE untuk respons streaming.

Jangan ragu untuk bereksperimen dengan opsi kuantisasi yang berbeda dan fitur Apidog untuk menemukan pengaturan yang paling sesuai untuk kebutuhan spesifik Anda!