Claude Haiku 5.5 and Nano Banana 2.1 are now live on CometAPI →
guide/Penyelidikan CometAPI

Cara Menghoskan Qwen 3.8 Max Secara Tempatan: Perkakasan, vLLM, SGLang dan Panduan Kuantisasi

Di bawah ialah panduan menyeluruh untuk menyediakan dan melancarkan model Qwen berskala besar secara setempat menggunakan pemberat terbuka (contoh: “Qwen3.8-2.4T-A95B”), dengan fokus kepada keperluan GPU, mod FP8/FP4 (atau 4-bit), integrasi vLLM dan SGLang, tetingkap konteks 1M, serta pengoptimuman produksi. Gantikan nama model/rujukan laluan dengan model sebenar yang anda miliki. Ringkasan pantas - Saiz model: ~A95B (±95B parameter) adalah kategori “ultra-besar”; perlu multi-GPU. - Mod ketepatan: - FP16/BF16: + ketepatan, – memori - FP8: kompromi baik (perlu GPU Hopper/Ada dan TE) - 4-bit (AWQ/GPTQ): penjimatan memori besar, sedikit susut kualiti - Rangka kerja pelayan: vLLM atau SGLang, kedua-duanya menyokong batching berterusan dan pengurusan KV-cache lanjutan. - Konteks 1M: hanya praktikal jika model dilatih/diubah suai untuk long context dan anda menggunakan strategi pengurangan memori (KV-cache quantization/offload/sliding window). 1) Prasyarat sistem - OS: Linux x86_64 moden (Ubuntu 22.04 disyorkan) - Pemacu GPU & CUDA: - NVIDIA Driver terkini yang sepadan CUDA 12.x - CUDA Toolkit 12.x (atau gunakan imej Docker dengan CUDA 12.x) - cuDNN/Transformer Engine (TE) jika ingin FP8 sebenar - Python 3.10/3.11 dengan pip/venv - Storan: NVMe SSD pantas (≥2–4 TB) untuk pemberat/indeks/cache - Rangkaian: Jika memuat turun dari repositori, sediakan token/pintu masuk yang diperlukan 2) Keperluan GPU dan anggaran memori Anggaran kasar memori hanya untuk pemberat (tidak termasuk KV-cache dan overhead): - FP16/BF16: ~2 bait/parameter ⇒ ~190 GB untuk ±95B - FP8: ~1 bait/parameter ⇒ ~95 GB - 4-bit (AWQ/GPTQ): ~0.5 bait/parameter (+overhead) ⇒ ~50–60 GB Nota penting: - KV-cache untuk konteks panjang (contoh 1M token) boleh mengatasi memori pemberat dengan margin besar. Tanpa strategi seperti quantization KV-cache, offload, atau perhatian gelangsar, 1M jarang praktikal walaupun dengan banyak GPU. - Disarankan GPU kelas data center dengan memori besar dan interkoneksi pantas: - H100/H200 (80 GB) atau A100/A800 (80 GB) atau L40S (48 GB) - NVLink sangat membantu untuk beban ultra-besar - Contoh konfigurasi bijak: - FP8: 2–4× H100 80 GB (bergantung pada overhead dan KV-cache) - 4-bit: 2× L40S 48 GB atau 2× A100 80 GB boleh mencukupi untuk pemberat; perlu rancang KV-cache dengan teliti 3) Perolehan model - Pastikan anda benar-benar mempunyai “pemberat terbuka” untuk model sasaran. - Simpan di direktori setempat, contoh: - /models/Qwen3.8-2.4T-A95B - Untuk 4-bit: - Jika gunakan AWQ/GPTQ, pastikan model telah dipra-kuantis (atau sediakan pipeline pra-kuantisasi) - Untuk FP8: - Pastikan stack FP8 tersedia (GPU Hopper/Ada + NVIDIA Transformer Engine). Tidak semua pipeline menyokong FP8 penuh out-of-the-box. 4) Konfigurasi tetingkap konteks 1M - Gunakan model yang benar-benar menyokong tetingkap konteks panjang (latihan/penalaan dengan RoPE scaling atau teknik setara). - Semak fail konfigurasi HF (contoh rope_scaling, max_position_embeddings). Jika model tidak menyokong 1M secara natif, anda memerlukan teknik lanjutan (contoh NTK/YARN/linear scaling) yang mesti sepadan dengan latihan/penalaan—sekadar menetapkan max length tanpa sokongan model akan merosakkan kualiti. - Gunakan strategi memori: - KV-cache quantization (FP8/4-bit) jika disokong - KV-cache offload ke CPU/NVMe untuk prefill panjang - Sliding-window/sparse attention jika tersedia - Chunked prefill (pemecahan prefill kepada kepingan kecil) 5) Pelancaran dengan vLLM (serving API) Pemasangan - Buat persekitaran: - python -m venv .venv && source .venv/bin/activate - pip install --upgrade pip - pip install vllm - Untuk FP8: pasang juga transformer-engine (serasi GPU dan driver); rujuk dokumentasi TE dan vLLM versi yang menyokong FP8. Pelancaran asas (Python API) - Gunakan API Python untuk mengawal lebih baik parameter: - from vllm import LLM, SamplingParams - llm = LLM( model="/models/Qwen3.8-2.4T-A95B", tensor_parallel_size=4, # bilangan GPU max_model_len=1_000_000, # jika model menyokong 1M dtype="bfloat16", # atau "auto" quantization="awq" # pilihan: "awq", "gptq", None; set FP8 ikut sokongan ) - params = SamplingParams(temperature=0.7, top_p=0.9, max_tokens=1024) - llm.generate(["Arahan anda di sini"], params) - Nota: - Jika menggunakan 4-bit, sediakan model AWQ/GPTQ dahulu; set quantization selaras dengan model. - Untuk FP8, gunakan dtype/konfigurasi yang disokong versi vLLM anda (sesetengah binaan nightlies/TE diperlukan). Pastikan keserasian sebelum produksi. - Pelayan HTTP (API server): - python -m vllm.entrypoints.api_server \ --model /models/Qwen3.8-2.4T-A95B \ --tensor-parallel-size 4 \ --max-model-len 1000000 \ --dtype bfloat16 \ --quantization awq \ --gpu-memory-utilization 0.90 \ --host 0.0.0.0 --port 8000 - Parameter praktikal: - --tensor-parallel-size: sepadankan dengan bilangan GPU - --gpu-memory-utilization: 0.85–0.95 untuk penggunaan memori agresif - --max-model-len: tetapkan hanya jika model benar-benar menyokongnya - --quantization: gunakan nilai yang sepadan dengan model/artefak (awq/gptq/None) - Gunakan continuous batching (lalai vLLM) untuk throughput Pengurusan KV-cache di vLLM - Aktifkan/konfigurasi paged KV (lalai di vLLM moden) - Jika tersedia dalam versi anda: - Gunakan KV-cache quantization (FP8) untuk jimat memori - Prefill chunking: pisahkan prompt panjang kepada blok untuk mengekalkan kestabilan dan penggunaan memori rendah 6) Pelancaran dengan SGLang Pemasangan - python -m venv .venv && source .venv/bin/activate - pip install sglang - Untuk FP8, pastikan transformer-engine/komponen CUDA yang berkaitan dipasang. Pelancaran asas - SGLang menyediakan server inference dengan continuous batching, speculative decoding, dan prefill chunking: - python -m sglang.launch_server \ --model /models/Qwen3.8-2.4T-A95B \ --tp 4 \ --max-context-len 1000000 \ --dtype bfloat16 \ --quantization awq \ --host 0.0.0.0 --port 8000 - Cadangan: - Hidupkan chunked prefill untuk prompt panjang - Gunakan speculative decoding (jika sesuai dan model draf tersedia) untuk mempercepat decode - Sesuaikan scheduler/batching mengikut SLA latency 7) FP8 dan FP4/4-bit: amalan terbaik - FP8: - Memerlukan GPU Hopper/Ada (H100/H200/L40S) dan TE - Set FP8 untuk lapisan linear utama; uji kestabilan output - Perlu semakan keserasian kernel (FMHA, GEMM) versi CUDA/driver - 4-bit (FP4 setara dari perspektif storan pemberat): - AWQ (W4A16) atau GPTQ: - AWQ: latensi baik, perlu model yang dipra-kuantis - GPTQ: juga popular, latensi sedikit berbeza bergantung kernel - Perhatikan: - Penurunan ketepatan kecil dijangka; uji dengan set penanda aras dalaman - Pastikan quant scales/metadata disertakan (awq_config/gptq config) 8) Konteks 1M: strategi praktikal - Pastikan model benar-benar dilatih/ditala untuk 1M; jika tidak, gunakan: - RoPE scaling yang betul (linear/NTK/YARN) mengikut latihan - Sliding Window Attention (SWA) atau teknik sparsity jika tersedia - Kurangkan kos KV: - Quantize KV-cache (FP8/4-bit) jika disokong - KV offload ke CPU/NVMe semasa prefill - Gunakan chunked prefill dan streaming output - Hadkan panjang decode: - Tetapkan max_new_tokens yang munasabah - Gunakan cache/prompt reuse (prefix caching) untuk kes penggunaan berulang 9) Pengoptimuman produksi - Throughput vs latency: - Sesuaikan saiz batch, max_num_batched_tokens, dan keutamaan permintaan - Gunakan continuous batching; kumpulkan permintaan prefill panjang untuk efisiensi - Prefill/decode: - Gunakan prefill chunking untuk beban panjang - Pertimbangkan speculative decoding (SGLang) atau draft model untuk decode laju - Pengurusan memori: - Naikkan gpu-memory-utilization dengan berhati-hati - Hidupkan KV-cache compression/quantization - Offload pemberat kurang kritikal/attention KV ke CPU/NVMe jika perlu - Kebolehskalaan: - Tensor parallel (TP) merentasi GPU dengan NVLink - Skala mendatar: jalankan berbilang replika di belakang load balancer - Kebolehpercayaan: - Warmup model (jalankan permintaan dummy pada permulaan) - Healthcheck dan autoscaling berdasarkan QPS/latency - Observability: metrik GPU (utilization/mem), latency per tahap (prefill/decode), rate error - Keselamatan dan tadbir urus: - Hadkan panjang prompt/output - Penapisan kandungan/pematuhan dasar - Audit log dan versi model yang jelas - Pengemasan: - Gunakan pinned dependencies untuk mengelakkan regresi kernel - Uji kombinasi driver/CUDA/TE sebelum naik taraf produksi 10) Ujian dan penentukuran - Ujian fungsian: - Periksa keserasian 1M dengan sampel prompt panjang - Pastikan kualiti tidak merosot ketara selepas FP8/4-bit - Penanda aras: - Ukur prefill throughput (tok/s) dan decode latency untuk pelbagai panjang - Uji di bawah beban serentak; sesuaikan batching/scheduler - Tuning: - Laraskan TP size, max_model_len, quantization, dan parameter batching - Pantau out-of-memory; kurangkan max_num_batched_tokens atau aktifkan offload 11) Ringkas konfigurasi cadangan mengikut sasaran - Latency rendah, kualiti tinggi: - BF16/FP16 di 4× H100 80 GB, continuous batching, prefill chunking - Seimbang kos/kelajuan: - FP8 di 2–4× H100/L40S; KV-cache FP8 jika sokong - Kos minimum: - 4-bit (AWQ/GPTQ) di 2× L40S/A100; KV-cache quant/offload; hadkan konteks efektif jika perlu Penutup - Pastikan ketersediaan sebenar “Qwen3.8-2.4T-A95B” (pemberat terbuka) dan keserasian rangka kerja dengan mod FP8/FP4 yang anda sasarkan. - Untuk 1M konteks, kejayaan banyak bergantung pada latihan model, strategi KV-cache, dan infrastruktur GPU/IO. - Mulakan dengan prototaip (quant 4-bit atau FP8), sahkan kualiti, kemudian naik taraf ke kluster GPU bersesuaian serta aktifkan optimisasi produksi (batching, prefill chunking, KV quant/offload, observability).

CometAPI
Deon GoodwinPasukan penyelidikan model AI dan API
Dikemas kini Sep 25, 2026 13 min baca
Cara Menghoskan Qwen 3.8 Max Secara Tempatan: Perkakasan, vLLM, SGLang dan Panduan Kuantisasi
Guna corak ini

Buat panggilan API pertama.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_COMETAPI_KEY",
    base_url="https://api.cometapi.com/v1",
)

response = client.chat.completions.create(
    model="gpt-5-mini",
    messages=[{"role": "user", "content": "Build this workflow."}],
)

print(response.choices[0].message.content)

Menjalankan Qwen3.8-Max secara setempat kini boleh dilakukan, tetapi frasa “Qwen 3.8 Max secara setempat” memerlukan satu penjelasan penting. Produk Max hos Alibaba dan checkpoint boleh muat turun berkait rapat, namun ia bukan produk yang serupa.

Qwen mula melancarkan perkhidmatan Max hos pada awal Ogos 2026 dan mengeluarkan Qwen3.8-2.4T-A95B sebagai berat terbuka pada 12 Ogos 2026. Checkpoint itulah model yang anda benar-benar gunakan pada infrastruktur sendiri.

Ini bukan tutorial Ollama-di-atas-PC-permainan yang biasa. Checkpoint tanpa kuantis ialah model Mixture-of-Experts 2.4 trilion parameter, dan resepi vLLM semasa menganggarkan berat BF16 bersaiz 4.45 TiB. Malah varian orientasi produksi berketepatan 4-bit terapung masih memakan kira-kira 1.3–1.5 TiB berat.

Jawapan ringkas: pengehosan sendiri kelas penuh Qwen 3.8 Max ialah penyebaran pusat data. Titik permulaan produksi yang praktikal ialah checkpoint FP4 pada 8× B300 atau 8× MI355X GPU; penyebaran H200 memerlukan lebih banyak GPU. Untuk stesen kerja biasa, gunakan Qwen3.8-27B.

Qwen 3.8 Max vs. Model Terbuka yang Anda Benar-benar Sebarkan

Checkpoint boleh muat turun Qwen3.8-2.4T-A95B secara rasmi digambarkan sebagai model bahasa kausal 2.4T-parameter dengan kira-kira 95B parameter diaktifkan setiap token. Perkhidmatan Max hos menambah keupayaan lapisan produk yang tidak hadir dalam checkpoint terbuka semasa.

SpesifikasiPerkhidmatan hos Qwen3.8-MaxCheckpoint terbuka Qwen3.8-2.4T-A95B
Jumlah parameter2.4T2.4T
Parameter aktif~95B~95B
Seni binaSparse MoESparse MoE
InputTeks, imej, videoTeks
Konteks1M konteks terurus262,144 asli; boleh diperluas ke ~1.01M
Tingkah laku fikirFikiran terurus / tanpa fikiranFikiran diperlukan; usaha penaakulan boleh dikonfigurasi
Alat terbina dalamTersedia pada perkhidmatan terurusAplikasi mesti menyediakan alat
Pengehosan sendiriTiada pengurusan berat diperlukanYa; checkpoint terbuka

Produk hos mendedahkan input teks, imej, dan video dengan konteks 1,000,000 token. Sebaliknya, checkpoint terbuka ialah teks sahaja dan mempunyai konteks asli 262,144 token. Perbezaan ini penting jika aplikasi anda bergantung pada input multimodal atau alat terbina dalam terurus.

Seni Bina dan Spesifikasi Qwen 3.8

CometAPI telah meliputi latar belakang model dalam What is Qwen3.8 Max, jadi panduan penyebaran ini mengekalkan perbincangan seni bina tertumpu pada butiran yang mempengaruhi memori, paralelisme, dan penyajian.

Spesifikasi berkaitan penyebaranQwen3.8-2.4T-A95B
Jumlah / parameter aktif2.4T / ~95B setiap token
Susun atur lapisan92 lapisan: 69 Gated DeltaNet + 23 perhatian penuh
Perutean MoE512 pakar dirutekan; 10 dirutek + 1 dikongsi aktif
Kepala perhatian penuh64 kepala query / 4 kepala key-value
Konteks asli262,144 token
Konteks diperluasSehingga kira-kira 1,010,000 token
Ramalan Berbilang TokenDisokong
Modality checkpoint terbukaTeks sahaja

Cara Menghoskan Qwen 3.8 Max Secara Tempatan: Perkakasan, vLLM, SGLang dan Panduan Kuantisasi

Seni bina model hibrid Qwen rasmi yang digunakan dalam panduan penyebaran SGLang Qwen3.8.

Jangan tafsir “95B parameter aktif” sebagai jejak memori model 95B. Pengaktifan jarang mengurangkan komput per token, tetapi sistem penyajian masih perlu mengakses keseluruhan set berat pakar.

Snapshot Penanda Aras Qwen 3.8 Max

Memandangkan tinjauan Qwen3.8 Max sedia ada oleh CometAPI sudah membincangkan penanda aras secara terperinci, artikel ini hanya menggunakan subset berkaitan penyebaran daripada jadual penanda aras kad model rasmi Qwen.

Penanda arasQwen3.8-MaxQwen3.7-MaxGPT-5.6 Sol (max)
Terminal Bench 2.186.674.588.8
SWE-bench Pro67.760.664.6
PaperBench93.064.890.5
FrontierSWE73.540.7—
CoWorkBench74.864.671.5
GPQA Diamond92.692.494.1

Cara Menghoskan Qwen 3.8 Max Secara Tempatan: Perkakasan, vLLM, SGLang dan Panduan Kuantisasi

Grafik prestasi Qwen3.8 rasmi yang diterbitkan oleh pasukan Qwen.

Kenaikan terbesar yang dilaporkan berbanding Qwen3.7-Max dalam subset ini ialah PaperBench dan FrontierSWE. Qwen3.8-Max juga melebihi GPT-5.6 Sol pada SWE-bench Pro dan PaperBench, manakala GPT-5.6 Sol kekal di hadapan pada Terminal Bench 2.1. Untuk keputusan penyebaran, anggap ini sebagai konteks keupayaan; ukuran memori dan throughput penyajian di bawah lebih relevan dari segi operasi.

Jadual penanda aras bukan ranking sejagat. Harness, had masa, had konteks, akses alat, dan kuantisasi boleh mengubah keputusan. Jalankan penanda aras ke atas checkpoint, ketepatan, enjin penyajian, dan taburan prompt yang tepat anda rancang untuk digunakan.

Perkakasan Apakah yang Diperlukan Qwen3.8 untuk Penyebaran Setempat?

Keperluan GPU untuk Qwen3.8-2.4T-A95B

Ini ialah soalan penyebaran utama. Resepi vLLM Qwen3.8 semasa menerbitkan jejak checkpoint dan kiraan GPU realistik dengan ruang kepala runtime, yang lebih berguna daripada menganggar VRAM hanya daripada kiraan parameter.

KetepatanJejak beratB300 (268 GB)MI355X (288 GB)H200 (141 GB)Padanan terbaik
BF164.45 TiB24 GPU24 GPU48 GPUFideliti maksimum / penyelidikan
FP82.27 TiB16 GPU16 GPU32 GPUProduksi fideliti tinggi
MXFP41.45 TiB—8 GPU16 GPUPenyebaran AMD praktikal
NVFP4 W4A41.32 TiB8 GPU—16 GPUPenyebaran NVIDIA praktikal

Bagi kebanyakan organisasi yang benar-benar memerlukan Qwen3.8 dihos sendiri, FP4 ialah titik permulaan yang praktikal. Konfigurasi NVIDIA yang menonjol ialah NVFP4 W4A4 pada 8× B300; laluan AMD yang sepadan ialah MXFP4 pada 8× MI355X.

Pelayan 8× H200 tidak mencukupi untuk penyebaran model penuh yang disyorkan ini. Resepi rasmi menganggarkan H200 pada 16 GPU untuk FP4, 32 untuk FP8, dan 48 untuk BF16.

Keperluan VRAM untuk Qwen3.8-27B

Qwen3.8-27B ialah alternatif kelas stesen kerja yang praktikal. Memori berat mentah adalah kira-kira 54 GB dalam BF16, 27 GB dalam FP8, dan 13.5 GB pada ketepatan 4-bit. Overhed runtime dan KV cache meningkatkan keperluan sebenar, terutamanya pada panjang konteks yang panjang.

KetepatanAnggaran memori beratPanduan penyebaran praktikal
BF16~54 GBGunakan GPU 64–80 GB, bergantung pada konteks dan overhed penyajian.
FP8 / INT8~27 GBGPU 40–48 GB menyediakan ruang kepala runtime yang lebih praktikal.
4-bit~13.5 GBGPU pengguna 20–24 GB boleh digunakan pada panjang konteks sederhana.

Angka ini ialah anggaran perancangan yang diperoleh daripada kiraan parameter. Sahkan checkpoint tepat, format kuantisasi, enjin penyajian, panjang konteks, dan tetapan KV-cache sebelum menyukat perkakasan produksi.

Bolehkah Qwen3.8 Dijalankan pada GPU Pengguna?

Model penuh Qwen3.8-2.4T-A95B tidak praktikal pada GPU pengguna biasa, walaupun apabila dikuantis secara agresif. Projek komuniti telah menunjukkan binaan UD-Q1_0 mampatan agresif 397 GB merentasi empat sistem DGX Spark, tetapi laluan itu ialah kuantisasi ekstrem eksperimen dan bukan garis dasar untuk penyajian sensitif kualiti.

Untuk stesen kerja atau makmal rumah, model yang lebih sesuai ialah Qwen3.8-27B, yang berat terbukanya dikeluarkan pada 14 Ogos 2026. Model ini jauh lebih mudah untuk dihos dan merupakan pilihan yang tepat jika “setempat” bermaksud satu stesen kerja dan bukannya kluster GPU.

Sebelum Anda Memasang Qwen 3.8 Max

Rancang infrastruktur sebelum menjalankan arahan pemasangan. Anda memerlukan Linux, timbunan pemecut yang serasi, storan setempat atau kongsi yang mencukupi untuk checkpoint, interkoneksi GPU jalur lebar tinggi, dan—apabila merentasi nod—rangkaian yang direka untuk inferens teragih. Resepi vLLM kini mengesyorkan vLLM nightly dan Transformers 5.4.0 atau lebih baharu.

bash

uv venv
source .venv/bin/activate

uv pip install -U vllm \
  --extra-index-url https://wheels.vllm.ai/nightly

uv pip install -U "transformers>=5.4.0"

Cara Menyebarkan Qwen 3.8 FP8 dengan vLLM

FP8 ialah pilihan munasabah apabila anda mahukan checkpoint yang disediakan Qwen dan mampu infrastruktur berbilang nod. Checkpoint rasmi ialah Qwen/Qwen3.8-2.4T-A95B-FP8.

Untuk penyebaran dua nod, 16-GPU kelas B300, jalankan nod ketua dengan:

bash

export HEAD_ADDR="10.0.0.10"

vllm serve Qwen/Qwen3.8-2.4T-A95B-FP8 \
  --tensor-parallel-size 16 \
  --nnodes 2 \
  --node-rank 0 \
  --master-addr "$HEAD_ADDR" \
  --max-model-len 262144 \
  --kv-cache-dtype fp8 \
  --reasoning-parser qwen3
Pada nod pekerja, gunakan topologi yang sama dengan pangkat nod berbeza dan tanpa pelayan API:

bash

export HEAD_ADDR="10.0.0.10"

vllm serve Qwen/Qwen3.8-2.4T-A95B-FP8 \
  --tensor-parallel-size 16 \
  --nnodes 2 \
  --node-rank 1 \
  --master-addr "$HEAD_ADDR" \
  --headless \
  --max-model-len 262144 \
  --kv-cache-dtype fp8 \
  --reasoning-parser qwen3

Jangan salin contoh 16-GPU ini ke pelayan H200 tanpa mengubah saiz topologi. Varian FP8 yang sama kini dianggarkan pada 32× H200 dalam resepi vLLM.

Cara Menjalankan Qwen 3.8 pada Satu Pelayan 8× B300

Untuk NVIDIA Blackwell, konfigurasi model penuh yang paling praktikal ialah NVFP4. vLLM kini mengesahkan NVFP4 W4A4 dengan paralelisme tensor merentasi lapan GPU B300.

bash

vllm serve Inferact/Qwen3.8-2.4T-A95B-NVFP4 \
  --tensor-parallel-size 8 \
  --max-model-len 262144 \
  --kv-cache-dtype fp8 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder

Binaan NVFP4 oleh Inferact ialah checkpoint dikuantis dan bukannya artifak BF16 Qwen asal. Sahkan kualiti model pada set penerimaan anda sendiri sebelum menganggapnya sebagai pengganti satu-ke-satu untuk BF16 atau FP8.

Cara Menyebarkan Qwen 3.8 dengan SGLang

SGLang menambah sokongan Hari-0 untuk Qwen3.8 pada 12 Ogos dan amat menarik untuk penyajian throughput tinggi, caching prefiks, paralelisme pakar, pengekodan spekulatif, serta pemisahan prefill/decode.

bash

SGLANG_ENABLE_MOE_DEFERRED_FINALIZE=1 \
SGLANG_FLASHINFER_MNNVL_CUTEDSL_AR_FUSION=1 \
sglang serve \
  --trust-remote-code \
  --model-path RadixArk/Qwen3.8-2.4T-A95B-NVFP4 \
  --tp-size 8 \
  --context-length 200000 \
  --preferred-sampling-params '{"top_k": 20}' \
  --attention-backend trtllm_mha \
  --linear-attn-prefill-backend flashinfer \
  --linear-attn-decode-backend flashinfer \
  --reasoning-parser qwen3 \
  --tool-call-parser qwen3_coder \
  --host 0.0.0.0 \
  --port 30000

SGLang melaporkan 346 token output/s pada saiz kelompok 1 di TP8 B300 dengan MTP, dan throughput agregat yang jauh lebih tinggi dalam susun atur penyajian terpisah. Anggap angka tersebut sebagai ukuran timbunan penyajian, bukan penanda aras kualiti model.

Uji Endpoint Serasi OpenAI Setempat

Kedua-dua vLLM dan SGLang mendedahkan API serasi OpenAI, yang menjadikan integrasi aplikasi mudah.

python

from openai import OpenAI

client = OpenAI(
    api_key="EMPTY",
    base_url="http://localhost:8000/v1",
    timeout=3600,
)

response = client.chat.completions.create(
    model="Qwen/Qwen3.8-2.4T-A95B-FP8",
    messages=[
        {
            "role": "user",
            "content": "Design a fault-tolerant Redis architecture for three regions."
        }
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=8192,
)

print(response.choices[0].message.content)

Kad model rasmi mengesyorkan temperature=1.0, top_p=0.95, dan top_k=20 sebagai parameter sampling garis dasar. Untuk kerja agen, tinggalkan belanjawan output yang mencukupi untuk penaakulan dan bukannya menetapkan max_tokens hanya untuk jawapan akhir yang kelihatan.

Dayakan Tetingkap Konteks 1M

Checkpoint terbuka Qwen3.8-2.4T-A95B mempunyai konteks asli 262,144 token dan boleh diperluas ke kira-kira 1.01M. Resepi vLLM mendokumenkan corak berikut:

bash

VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 \
vllm serve Qwen/Qwen3.8-2.4T-A95B-FP8 \
  --max-model-len 1010000 \
  --hf-overrides '{"max_position_embeddings": 1010000}' \
  --reasoning-parser qwen3 \
  ...

Jangan jadikan 1M sebagai lalai hanya kerana ia disokong. Konteks maksimum yang lebih besar menempah lebih banyak kapasiti cache dan boleh mengurangkan kebersamaan dengan ketara. Tetapkan --max-model-len kepada beban kerja sebenar.

Bagaimana Mempertingkat Prestasi Inferens Qwen3.8?

Guna MTP-3 untuk Mengurangkan Kependaman Pengguna Tunggal

Qwen3.8 menyertakan Multi-Token Prediction. Dalam ukuran terbitan vLLM, MTP-3 memindahkan output per pengguna daripada 130 ke 307 tok/s untuk FP8 TP16 dan daripada 133 ke 304 tok/s untuk NVFP4 TP8.

bash

--speculative-config '{"method":"mtp","num_speculative_tokens":3}'

Guna fastsafetensors untuk Permulaan Lebih Pantas

Untuk model berskala terabait, masa permulaan penting. Dalam satu ukuran vLLM, pemuatan berat jatuh daripada 545 s kepada 306 s dengan fastsafetensors dan pemuatan malas.

bash

--load-format fastsafetensors \
--safetensors-load-strategy lazy

Guna Paralelisme Pakar untuk Meningkatkan Throughput Serentak

Untuk kebersamaan tinggi, Qwen3.8 mendapat manfaat daripada susun atur paralel pakar kerana ia mempunyai 512 pakar dirutek. vLLM melaporkan sehingga 3,200 jumlah tok/s/GPU untuk FP8 EP dan sehingga 4,300 jumlah tok/s/GPU untuk konfigurasi NVFP4 DEP16 yang dioptimumkan.

Tetapkan --max-model-len untuk Mengimbangi VRAM dan Kebersamaan

Tetapkan --max-model-len kepada jujukan terpanjang yang benar-benar diperlukan oleh beban kerja. Nilai yang lebih besar menempah lebih banyak kapasiti KV-cache, meningkatkan tekanan memori, dan boleh mengurangkan bilangan permintaan serentak walaupun berat model sudah muat.

Mulakan dengan persentil produksi yang mewakili bukannya konteks maksimum yang diiklankan model. Uji beban had yang dipilih dengan ketepatan, corak kelompok, dan enjin penyajian yang sama digunakan dalam produksi, kemudian naikkan hanya apabila permintaan sebenar memerlukan lebih konteks.

Penyebaran Setempat Qwen 3.8 Max vs. API

Berat terbuka tidak secara automatik menjadikan inferens setempat ekonomik. Keputusan yang betul bergantung pada penggunaan, residensi data, kakitangan, sasaran ketersediaan, dan sama ada anda benar-benar memerlukan ciri multimodal model terurus.

DimensiQwen3.8-2.4T-A95B dihos sendiriQwen3.8-Max melalui CometAPI
InfrastrukturPelayan atau kluster berbilang GPUTiada infrastruktur GPU
Modality inputTeksTeks, imej, video
Konteks262K asli; ~1.01M diperluas1M terurus
Kawalan dataMaksimumAPI awan
OperasiAnda memiliki pemantauan, naik taraf, dan HADiurus penyedia
Padanan terbaikResidensi data, penggunaan berterusan, pasukan infraKebanyakan pasukan aplikasi dan beban berubah

Jika anda sudah memiliki pemecut yang sesuai dan mempunyai penggunaan yang konsisten tinggi, pengehosan sendiri boleh dibenarkan. Jika anda akan membeli kluster hanya untuk model ini, Qwen3.8-Max di CometAPI biasanya laluan geseran lebih rendah. Panduan API sedia ada meliputi integrasi hos, manakala panduan harga meliputi pemodelan kos; oleh itu artikel ini kekal tertumpu pada penyebaran setempat.

Masalah Biasa Penyebaran Setempat Qwen 3.8

Pelayan Kehabisan Memori GPU Semasa Permulaan

Kurangkan dahulu --max-model-len jika cache ialah isu. Jika berat itu sendiri tidak muat, pengurangan konteks tidak akan menyelesaikan punca; beralih kepada checkpoint berketepatan lebih rendah yang disahkan atau tambah GPU.

Paralelisme Tensor Gagal dengan Saiz Tidak Sah

Qwen3.8 mempunyai 64 kepala perhatian dalam lapisan perhatian penuhnya, jadi vLLM memerlukan TP membahagi 64. Saiz TP yang mudah ialah 1, 2, 4, 8, 16, dan 32. Jumlah VRAM agregat semata-mata tidak mencukupi untuk memilih topologi.

Pelayan Mengambil Masa Lama untuk Mula

Memuatkan satu hingga beberapa terabait berat ditambah JIT kernel boleh mengambil masa beberapa minit. Tingkatkan VLLM_ENGINE_READY_TIMEOUT_S dan prob endpoint inferens sebenar dan bukan menganggap tetingkap permulaan yang singkat.

Model Setempat Tidak Dapat Memproses Imej

Itu dijangka. Checkpoint terbuka 2.4T ialah teks sahaja. Input multimodal tergolong dalam produk Qwen3.8-Max terurus.

Checkpoint terbuka Qwen3.8-2.4T-A95B ialah teks sahaja. Had ini khusus untuk Qwen3.8-2.4T-A95B. Qwen3.8-27B menyokong input visual apabila fail unjuran visi berasingan dimuatkan.

Konteks 1M Mengurangkan Throughput secara Dramatik

Kurangkan --max-model-len kepada jujukan terpanjang yang benar-benar diperlukan oleh beban kerja anda. Tetingkap konteks terbesar yang disokong bukan semestinya tetapan produksi terbaik; pilih had konteks yang mengimbangkan keperluan beban kerja, penggunaan KV-cache, dan kebersamaan.

Bolehkah Ollama atau LM Studio Menjalankan Qwen 3.8 Max?

Ekosistem boleh membungkus berat Qwen3.8 yang dikuantis secara berat untuk inferens gaya llama.cpp, tetapi itu tidak harus dikelirukan dengan aliran kerja Ollama desktop biasa. Binaan dikuantis yang memakan ratusan gigabait masih memerlukan ratusan gigabait memori boleh akses dan melibatkan kompromi ketara dalam kualiti dan prestasi.

Untuk pembangunan setempat biasa, Qwen3.8-27B ialah sasaran yang sesuai. Model penuh 2.4T harus dianggap sebagai model pelayan/kluster walaupun apabila kuantis komuniti ekstrem menjadikannya boleh but secara teknikal pada perkakasan luar biasa.

Kaedah Penyebaran Mana yang Harus Anda Pilih?

Untuk NVIDIA Blackwell, penyebaran 8× B300 NVFP4 kini merupakan titik permulaan model penuh paling bersih. Untuk AMD, 8× MI355X dengan MXFP4 ialah konfigurasi praktikal yang sepadan. Gunakan FP8 apabila anda mengutamakan provenance checkpoint dan kualiti berbanding saiz infrastruktur, dan BF16 hanya apabila fideliti maksimum membenarkan keperluan memori skala berbilang rak.

Untuk stesen kerja, gunakan Qwen3.8-27B. Untuk pasukan aplikasi yang memerlukan keupayaan Max tanpa operasi kluster GPU, gunakan model Qwen3.8-Max yang dihoskan di CometAPI.

Kesimpulan

Qwen3.8-Max telah menyeberangi sempadan penting sejak pelancaran API awalnya: keluarga Qwen kelas Max kini mempunyai checkpoint 2.4T terbuka yang boleh dikendalikan sepenuhnya oleh organisasi pada infrastruktur mereka sendiri.

Tetapi berat terbuka tidak bermaksud perkakasan pengguna. Jejak BF16 4.45 TiB, checkpoint FP8 2.27 TiB, dan varian FP4 1.3–1.5 TiB menjadikan Qwen3.8-2.4T-A95B antara model terbuka paling intensif infrastruktur yang tersedia. Kelebihan praktikalnya ialah vLLM dan SGLang sudah menyokong seni bina tersebut, dan FP4 menjadikan penyebaran satu nod 8× B300 atau 8× MI355X boleh dilaksanakan.

Hos sendiri apabila kawalan data, penggunaan berterusan, dan pemilikan infrastruktur membenarkan kluster. Jika tidak, gunakan API Max terurus—atau Qwen3.8-27B apabila apa yang anda benar-benar mahukan ialah model Qwen yang mantap pada satu stesen kerja.

Terus belajar

Sambungkan artikel ini ke keputusan seterusnya.

Lihat semua topik
Diterbitkan pada Sep 25, 2026
Terakhir dikemas kini Sep 25, 2026
98 paparan
Disemak untuk kejelasan, atribusi sumber dan terminologi API semasa.

Baca Lagi