hy4 GGUF: Mga antas ng quantization, kalkulasyon ng memorya, at mga utos na llama.cpp / Ollama
hy4 GGUF: Mga antas ng quantization, kalkulasyon ng memorya, at mga utos na llama.cpp / Ollama
Ang hy4 ang pinakamadaling i-host sa sarili sa loob ng pamilya ng Hunyuan: dense model na 4 bilyong parameter, inilalabas ng pinagmulan nang sabay ang FP8, GPTQ-Int4 at AWQ-Int4, at maraming may-akda ng GGUF conversion sa komunidad. Ang talagang nagpapalito ay hindi ang modelo kundi tatlong desisyong ikaw mismo ang magpapasya: aling antas ng quantization, magkano ang memorya, at aling framework ang gagamitin. Nilalakad ng artikulong ito ayon sa pagpasya, pagsukat, pagpapatakbo, at paglutas ng problema; lahat ng utos ay maaaring kopyahin nang direkta.
Buod sa 30 segundo
Ang inirerekumendang kombinasyon para sa unang pagtakbo ay komunidad na Q4_K_M GGUF kasama ang llama.cpp (llama-server para magbukas ng endpoint na katulad ng OpenAI). Ang tugatog ng memorya ay 2.5GB para sa timbang, 0.5GB para sa KV cache, at 0.5GB para sa gastos ng runtime, kaya sapat na ang 6GB na card. Ang mga gumagamit ng Mac ay mas mainam na lumipat sa 4bit conversion ng mlx-community.
Unang hakbang: pumili ng antas ng quantization
| Antas | Laki (sinukat mula sa imbakan ni bartowski) | Kalidad | Bagay na angkop |
|---|---|---|---|
| IQ4_XS | 2.37 GB | malapit sa Q4 | landas ng Q4 kapag masikip ang memorya |
| Q3_K_M | 2.17 GB | nakikitang pagkawala | kakasya lang sa 4GB na card |
| Q4_K_M | 2.61 GB | halos walang pagkawala | likas na pili, sapat para sa halos lahat ng gawain |
| Q5_K_M | 3.03 GB | malapit sa orihinal | piliin kapag may bahid ang memorya |
| Q6_K | 3.47 GB | halos katumbas ng orihinal | konserbatibong pili para sa mahabang pagbabalangkas |
| Q8_0 | 4.49 GB | sa pangkalahatan ay katumbas ng orihinal | ginagamit na pambanding sukatan ng katumpakan |
| FP16 (orihinal) | humigit-kumulang 8.4 GB | orihinal | tanging kailanmawaan ng FP16 inference stack |
Ang orihinal na laki ng timbang ay batay sa parameter na nasa model card: ang Hunyuan-4B-Instruct ay may 4.22 bilyong parameter, na humigit-kumulang 8.4GB sa BF16.
Ang praktikal na pagkakasunod ng pagpili
Magsimula sa Q4_K_M at tiyakin na ang utos, haba ng konteksto, at serbisyo ay umandar nang buo. Kapag sensitibo ang gawain mo sa katumpakan, tulad ng estrukturadong pagkuha o pagbabalangkas ng code, ihambing ang kinalabasan sa Q5_K_M. Tanging kapag kailangan mong bumuo ng batayan upang sukatin kung gaano karami ang nawawala dahil sa quantization, doon ka gagawa ng Q8_0 o FP16. Ang pagsisimula sa FP16 ay kadalasang pag-aaksaya lamang ng memorya.
Mga may-akda ng GGUF ng komunidad para sa hy4:
| May-akda | Katangian ng imbakan |
|---|---|
| bartowski | may lahat ng antas, pinakamataas ang download, ligtas na likas na pinagmumulan |
| mradermacher | nagbibigay ng karaniwang quantization at seryeng i1 |
| gabriellarson | karamihan ay karaniwang quantization |
| DevQuasar | karamihan ay karaniwang quantization |
| Disya | karamihan ay Q80_0, angkop sa mataas na paghahambing ng katumpakan |
| Edge-Quant | isang antas na Q4_K_M, pinakasimpleng pili |
Kapag nagda-download, basahin ang label ng quantization sa pangalan ng file (Q4_K_M, Q5_K_M, Q8_0) at ang pinagmumulan ng imbakan, huwag ituring na pareho ang magkaparehong pangalan ng file mula sa magkaibang may-akda.
Ikalawang hakbang: kalkulahin ang memorya, huwag ang timbang lamang
Ang kabuuang memorya ay ang kabuuan ng tatlong bahagi:
Kabuuang memorya ≈ Timbang + KV cache + Gastos ng runtime
Timbang: 4.22 bilyong parameter na pinaparami ng byte bawat parameter. Ang Q4_K_M ay humigit-kumulang 0.65 byte bawat parameter, ang Q8_0 ay humigit-kumulang 1.06, at ang FP16 ay 2.
KV cache: tumutubo nang linear ayon sa haba ng konteksto. Ang opisyal na konfigurasyon ng hy4 ay 36 layer, 8 KV head, at head dimension 128, na sa BF16 ay gumagamit ng humigit-kumulang 144KB bawat token:
KV cache ≈ 2 × 36 layer × 8 KV head × 128 head dim × haba ng konteksto × 2 byte
≈ 144KB × haba ng konteksto
Ang paghahambing: ang 4K na konteksto ay humigit-kumulang 0.56GB at ang 32K na konteksto ay humigit-kumulang 4.6GB. Ang opisyal na maximum na haba ng posisyon ng hy4 ay 262144 (256K), ngunit ang pagpupuno ng bintana ay nangangahulugang kakainin ng KV cache ang mahigit sa sampung GB, kaya ang talagang magagamit na haba ng konteksto ay dapat matuldok pabalik mula sa memorya, hindi kinopya mula sa label.
Isang mabilisang talasanggunian
Q4_K_M (2.61GB) na may 4K na konteksto: humigit-kumulang 2.6 + 0.6 + 0.5 = 3.7GB, masikip pero posible sa 4GB na card. Q4_K_M na may 32K na konteksto: humigit-kumulang 2.6 + 4.6 + 0.5 = 7.7GB, kailangan ng 8GB pataas. Q5_K_M na may 8K na konteksto: humigit-kumulang 3.0 + 1.1 + 0.5 = 4.6GB, angkop sa 6GB na card. Ang Q8_0 (4.49GB) ay kumain na ng kalahating card. Ang mga numerong ito ay pagtatantya lamang; ang tunay na bilang ay ang iniulat ng nvidia-smi kaagad pagkatapos ng unang pagkarga.
Ikatlong hakbang: patakbuhin gamit ang llama.cpp
# 1. Mag-download ng GGUF ng komunidad (halimbawang imbakan ni bartowski; baguhin ang pangalan ng file ayon sa listahan sa imbakan)
huggingface-cli download bartowski/tencent_Hunyuan-4B-Instruct-GGUF \
Q4_K_M.gguf --local-dir ./hunyuan4b
# 2. Diretsong pag-uusap upang matiyak na nagkakarga ang timbang
./llama-cli -m ./hunyuan4b/Q4_K_M.gguf -p "Ipaliwanag ang MoE sa tatlong pangungusap" -n 256
# 3. Magbukas ng serbisyong katulad ng OpenAI
./llama-server -m ./hunyuan4b/Q4_K_M.gguf \
--host 127.0.0.1 --port 8080 \
--ctx-size 32768 \
--jinja
Kapag tumakbo na ang serbisyo, ang kasalukuyang client ay nagpapalit lamang ng dalawang parameter:
from openai import OpenAI
client = OpenAI(
base_url="http://127.0.0.1:8080/v1",
api_key="not-needed",
)
resp = client.chat.completions.create(
model="local-model",
messages=[{"role": "user", "content": "Kumusta, ipakilala ang iyong sarili"}],
)
print(resp.choices[0].message.content)
Malaya ang pagpilian sa pangalan ng modelo, pero huwag maglagay ng tunay na API ID
Hindi mahigpit na binalidated ng llama-server ang pangalan ng modelo, kaya maaaring gamitin ng lokal na serbisyo ang local-model. Kapag hinahanap ng client mo ang pangalan ng modelo sa malayong katalogo, pakitulad ang lokal na endpoint at ang cloud na endpoint.
Ika-apat na hakbang: patakbuhin gamit ang Ollama
Ang halaga ng Ollama ay nasa dalang sarili nito na pamamahala ng modelo at ekosistema ng API, kaya agad itong nauunawaan ng mga tool tulad ng Open WebUI, Dify, at Cursor.
# 1. Lumikha ng modelo mula sa lokal na GGUF sa pamamagitan ng Modelfile
cat > Modelfile <<'EOF'
FROM ./hunyuan4b/Q4_K_M.gguf
TEMPLATE """{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Prompt }}<|im_start|>user
{{ .Prompt }}<|im_end|>
{{ end }}<|im_start|>assistant
"""
PARAMETER num_ctx 8192
PARAMETER temperature 0.7
EOF
ollama create hy4-local -f Modelfile
# 2. Patotohanan
ollama run hy4-local "Sumulat ng Python function na nag-aayos ng oras na ISO 8601"
# 3. Tingnan at alisin
ollama list
ollama show hy4-local
ollama rm hy4-local
Dapat kopyahin ang TEMPLATE mula sa model card
Ito ang pinakakatagong bitag kapag nagho-host ng sarili: nagkakarga ang modelo, lumalabas ang token, pero mahina ang kalidad ng sagot, kaya nagmumukhang mahina ang modelo. Ang dahilan ay halos laging hindi tumutugmang chat template, at magkakaiba ang template ng Hunyuan sa bawat henerasyon. Kopyahin ang template mula sa bahaging Usage ng tumutugmang model card at tandaan ang parameter na stop, kung hindi, hindi hihinto ang modelo.
Ika-limang hakbang: mga landas sa Mac at device sa gilid
| Platform | Landas | Tala |
|---|---|---|
| Apple Silicon | mlx-community/Hunyuan-4B-Instruct-4bit | diretsong nagkakarga gamit ang mlx-lm, ang unified memory ay nagpapadiretso ng epikto ng quantization |
| Edge at embedded | taobao-mnn/Hunyuan-4B-Instruct-MNN | makina ng inference ng MNN mula Alibaba para sa mobile at embedded |
| Lumang CPU | GGUF Q4/Q5 ng komunidad | backend na CPU ng llama.cpp, na may 4B bilang realistikong talukay |
# Mabilisang pagpapatotoo gamit ang MLX
pip install mlx-lm
python -m mlx_lm.generate --model mlx-community/Hunyuan-4B-Instruct-4bit \
--prompt "Ipaliwanag ang vector database sa isang pangungusap" --max-tokens 128
Kung paano makakakuha ng mapagkakatiwalaang palatandaan ng bilis
Huwag maniwala sa bilang na token/s ng iba. Ang CPU, bandwidth ng memorya, haba ng konteksto, at build ng engine ay nagpapalita ng kinalabasan. Ang tamang paraan ay sukatin sa iyong sariling makina: itatag ang prompt, itatag ang haba ng pagbabalangkas, patakbuhin nang tatlong pag-ikot at kunin ang median, habang nire-record ang rurok ng memorya. Itabi ang bilang na iyon bilang batayan upang ang susunod na pagpapalit ng antas ng quantization ay may maibabambing.
Tabla ng paglutas ng problema: mula sintomas patungong dahilan
| Sintomas | Pinakamalamang na dahilan | Lunas |
|---|---|---|
| Bigong magkarga dahil hindi sinusuportahan ang arkitektura | masyadong luma ang build ng llama.cpp | i-upgrade ang engine at muling suriin |
| Nagkarga pero kakaiba ang lumabas na teksto | mali ang chat template | itama ang TEMPLATE o ang --jinja ayon sa model card |
| Natapos dahil sa paghabol ng memorya | binilang lang ang timbang, nakalimutan ang KV cache | bawasan ang haba ng konteksto o gumamit ng mas mababang quantization |
| Napakabagal bawat token | ang bahagi ng mga layer ay napasok sa memorya ng sistema | gumamit ng mas maliit na quantization o mas maliit na modelo |
| Napakabagal ng unang token, at pagkaraan ay normal | nagkakarga ang timbang sa memorya sa unang pag-ikot | normal lang, painitin muna |
| Hindi umandar ang format ng pagtawag sa tool | nawawala sa template ang bahagi ng tool | idagdag ang bahaging tool ayon sa model card o palitan ang template |
| Paulit-ulit ang kinalabasan at hindi humihinto | matinding parameter ng sampling | ayusin ang temperature at top_p, at tiyaking may token na EOS |
FAQ
May opisyal na GGUF ba ang hy4?
Para sa unang pagpapatakbo, aling quantization ang dapat piliin?
Paano malalaman kung magkano ang memoryang kakailanganin?
Dapat bang pumili ng llama.cpp o Ollama?
Mahina ang kalidad ng kinalabasan. Ba't hindi maganda ang modelo?
Aling landas ang dapat kunin ng tagagamit ng Mac para sa hy4?
Maaari bang tawagan ang Hunyuan sa pamamagitan ng API?
Karagdagang pagbabasa
- Pahina ng modelong hy4 — ispesipikasyon, quantization matrix at kalkulasyon ng memorya
- Tala sa channel na hy4-preview — ang channel na may 1M na konteksto
- Buod ng pamilya ng Tencent Hunyuan — lahat ng linya ng produkto ng Hunyuan
- Gabay sa pagpili ng hy4 — mga laki at posisyon ng A13B
- Pagpapatakbo ng hy4 gamit ang Ollama — pag-uugnay ng lokal na endpoint sa mga development tool
- Open WebUI gamit ang lokal na Hunyuan — self-hosted na interface ng pag-uusap
- Gabay sa pagkalkula ng VRAM — pangkalahatang matematika ng memorya
- Manwal ng paglalapat sa lokal — mula sa pagsusuri ng hardware hanggang sa pag-uugnay ng tool
Mga pinagmulan
Ang listahan ng mga antas ng quantization at mga imbakan ay nagbabago ayon sa mga update ng komunidad; ang artikulong ito ay sumasalamin sa kalagayan noong panahon ng pagkuha ng sampol. Ang mga numerong pang-memorya ay mga tantyang batay sa karanasan, at ang iyong sariling sukat ang pangwakas.