Antrenare conștientă de cuantizare: un ghid pentru îmbunătățirea inferenței locale a lui Gemma 4

Ce este cuantizarea?

Cuantizarea este o tehnică de compresie a modelului care reduce precizia greutăților. 

Modelele lingvistice mari sunt de obicei stocate în formate cu precizie înaltă precum BF16 sau FP16, care păstrează calitatea, dar cer memorie semnificativă. Cuantizarea convertește acele greutăți în formate cu mai puțini biți, precum 8 biți sau 4 biți, astfel încât modelul folosește mai puțină VRAM și rulează mai ușor local. Hugging Face notează că cuantizarea pe 8 biți poate, în linii mari, să înjumătățească utilizarea memoriei, în timp ce cuantizarea pe 4 biți o poate reduce și mai mult.

Compromisul este că o precizie mai mică poate uneori reduce calitatea ieșirii, mai ales dacă modelul nu a fost optimizat pentru cuantizare. Pe scurt, BF16 și FP16 oferă de obicei cea mai bună calitate, dar folosesc mai multă memorie; modelele pe 8 biți sunt mai mici, păstrând de regulă o calitate puternică, iar modelele pe 4 biți sunt mult mai mici, dar pot pierde din acuratețe sau stabilitate. 

Pentru inferența locală, acest compromis merită adesea, deoarece permite rularea unor modele mai mari pe GPU-uri pentru consumatori, în loc să fie nevoie de hardware scump din centre de date.

Ce este antrenarea conștientă de cuantizare?

Quantization-Aware Training (QAT) este o tehnică prin care modelul este antrenat sau antrenat fin simulând comportamentul cu precizie redusă. Asta ajută modelul să rămână mai stabil după cuantizare și poate îmbunătăți performanța inferenței locale la lățimi mici de biți.

Ce face QAT diferit?

Abordarea obișnuită, cuantizarea post-antrenare, comprimă un model după ce a fost deja antrenat. Este simplu și practic, dar modelul poate pierde din calitate pentru că nu a fost antrenat să gestioneze greutăți cu precizie redusă. 

Conform documentației Google AI Edge, cuantizarea post-antrenare este un pas de conversie care poate reduce dimensiunea modelului și îmbunătăți latența, de obicei cu pierderi mici de acuratețe. Totuși, calitatea finală poate depinde în continuare de model și de nivelul de cuantizare. 

Quantization-Aware Training, sau QAT, abordează altfel. În loc să cuantizeze doar după antrenare, QAT simulează comportamentul cu precizie redusă în timpul antrenării sau antrenării fine. Asta ajută modelul să învețe cum să rămână stabil când este ulterior convertit într-un format mai mic. Minimizează pierderea de calitate atunci când modelul este comprimat.

De aceea Gemma 4 QAT este utilă pentru AI local. Este construită având în minte cuantizarea, astfel că poate păstra mai mult din calitatea modelului original folosind mai puțină memorie. Pentru utilizatorii care rulează modele pe GPU-uri pentru consumatori, asta poate însemna o stabilitate mai bună la biți puțini, utilizare mai mică de VRAM și o inferență locală mai practică.

Pasul 1: Instalează dependențele și construiește llama.cpp

Înainte de a descărca modelele, trebuie mai întâi să pregătim runtime-ul local. Acest tutorial a fost testat pe o mașină cu un GPU NVIDIA RTX 4090 și 24 GB VRAM. Vom folosi llama.cpp ca runtime de inferență, GGUF ca format al modelului și fișierele de model cuantizate UD-Q4_K_XL.

Configurație testată:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• Runtime: llama.cpp
• Format model: GGUF
• Cuantizare: UD-Q4_K_XL

Vom compara următoarele două modele Unsloth GGUF:

• unsloth/gemma-4-12B-it-GGUF
• unsloth/gemma-4-12B-it-qat-GGUF

Mai întâi, verifică dacă GPU-ul tău este disponibil.

nvidia-smi

Apoi, instalează pachetele de sistem necesare pentru a construi llama.cpp.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

Clonează repository-ul oficial llama.cpp.

git clone https://github.com/ggml-org/llama.cpp

Acum construiește llama.cpp cu suport CUDA activat. Asta permite rularea straturilor modelului pe GPU, nu doar pe CPU.

cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ON

Compilează binarele necesare.

cmake --build llama.cpp/build \
    --config Release \
    -j \
    --clean-first \
    --target llama-cli llama-mtmd-cli llama-server llama-gguf-split

După finalizarea build-ului, binarul principal pe care îl vom folosi este llama-server. Ne permite să rulăm local modelul GGUF și expune un endpoint API compatibil cu OpenAI pe care îl putem interoga cu curl. 

Pasul 2: Descarcă modelele Gemma 4 12B Non-QAT și QAT 

Acum că llama.cpp este gata, putem descărca ambele variante ale modelului Gemma 4 12B de pe Hugging Face. Vom descărca modelul instrucțional obișnuit și versiunea QAT în format GGUF.

Mai întâi, instalează Hugging Face Hub CLI cu suport de descărcare mai rapid.

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transfer

Activează descărcările Xet de înaltă performanță.

export HF_XET_HIGH_PERFORMANCE=1

Descarcă modelul instrucțional Gemma 4 12B obișnuit în format GGUF.

hf download unsloth/gemma-4-12B-it-GGUF \
  --local-dir models/gemma-4-12B-it-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Apoi, descarcă versiunea QAT folosind același format de cuantizare.

hf download unsloth/gemma-4-12B-it-qat-GGUF \
  --local-dir models/gemma-4-12B-it-qat-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Flag-urile --include se asigură că descărcăm doar fișierele necesare pentru acest tutorial, în loc să tragem întregul repository. Aici descărcăm fișierele de model GGUF UD-Q4_K_XL și fișierele mmproj-BF16 folosite de pachetul modelului. 

După ce se termină descărcările, confirmă că ambele foldere de model există.

ls models

Ieșire așteptată:

gemma-4-12B-it-GGUF
gemma-4-12B-it-qat-GGUF

În acest punct, atât modelele non-QAT, cât și QAT sunt disponibile local și le putem porni cu llama-server.

Pasul 3: Rulează modelul Non-QAT cu llama-server

Vom începe rulând modelul instrucțional Gemma 4 12B obișnuit. Asta ne oferă un punct de referință pentru a-l compara ulterior cu versiunea QAT, folosind aceleași setări.

Pornește modelul non-QAT cu llama-server.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Acest lucru pornește un server local compatibil cu OpenAI la http://localhost:8001.

Deschide un alt terminal și trimite o cerere către serverul local.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

În această comandă folosim endpoint-ul local /v1/chat/completions, care urmează formatul API compatibil cu OpenAI. Promptul cere modelului să explice antrenarea conștientă de cuantizare, iar max_tokens este setat la 512 pentru a ne asigura că ambele variante ale modelului sunt testate cu aceeași lungime a ieșirii. 

În testul nostru pe RTX 4090, modelul non-QAT a produs următoarele rezultate de timp:

• Tokeni în prompt: 40
• Tokeni în completare: 512
• Viteză prompt: 510.22 tokeni/sec
• Viteză generare: 94.65 tokeni/sec
• Timp total: 5.516 sec

Utilizarea memoriei GPU a fost:

9247 MiB / 24564 MiB

Acestea ne oferă performanța de bază pentru modelul Gemma 4 12B obișnuit. În pasul următor, vom rula versiunea QAT cu aceeași configurație și vom compara rezultatele.

Pasul 4: Rulează și testează modelul QAT

Acum vom rula versiunea QAT a lui Gemma 4 12B folosind aceleași setări llama-server. Asigură-te că oprești serverul non-QAT anterior înainte de a-l porni pe acesta, deoarece ambele comenzi folosesc același port.

Pornește modelul QAT.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-qat-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Acesta pornește modelul QAT pe același endpoint local compatibil cu OpenAI, http://localhost:8001.

Acum trimite același prompt de test către modelul QAT.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it-qat",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

În testul nostru pe RTX 4090, modelul QAT a produs următoarele rezultate de timp:

1. Tokeni în prompt: 40
2. Tokeni în completare: 512
3. Viteză prompt: 593.93 tokeni/sec
4. Viteză generare: 101.65 tokeni/sec
5. Timp total: 5.114 sec

Utilizarea memoriei GPU a fost:

8627 MiB / 24564 MiB

Poți, de asemenea, să copiezi URL-ul serverului local (http://localhost:8001) și să-l lipești în browser:

Asta deschide interfața web llama.cpp integrată, care îți oferă o interfață simplă, de tip ChatGPT, pentru testarea modelului local. O poți folosi ca să vorbești direct cu modelul QAT în browser, să experimentezi cu prompturi și să folosești modelul ca asistent AI local zilnic. 

Compară rezultatele QAT vs Non-QAT

După ce am testat ambele modele cu același prompt și aceleași setări ale serverului, le putem compara direct performanța pe RTX 4090.

În această rulare, modelul QAT a fost și mai rapid, și mai „ușor” decât modelul non-QAT. A folosit 620 MiB mai puțin VRAM, reducând utilizarea memoriei cu aproximativ 6,7%. Acest lucru este util pentru inferența locală, pentru că fiecare bit de VRAM economisit ajută când rulezi modele mari pe GPU-uri pentru consumatori.

Modelul QAT a și generat tokeni mai repede, îmbunătățind de la 94.65 tokeni/sec la 101.65 tokeni/sec. Asta înseamnă o creștere de ~7,4% a vitezei de generare, reducând timpul total de la 5,516 secunde la 5,114 secunde.

În utilizarea de zi cu zi, modelul QAT s-a simțit mai lin și mai receptiv. Calitatea răspunsurilor a părut, de asemenea, mai stabilă în acest test, ceea ce este motivul principal pentru care QAT este util: ajută modelul să gestioneze cuantizarea la biți puțini cu mai puține pierderi de calitate, păstrând în același timp avantajele de memorie și viteză ale unui model comprimat.

Gânduri finale

Google face o treabă grozavă pentru comunitatea AI locală. Cu modele precum Gemma 4 și tehnici precum QAT, visul de a rula local modele AI puternice, complet offline și chiar pe hardware pentru consumatori devine real. 

Partea cea mai interesantă este că nu e vorba doar de a reduce dimensiunea modelului. Cu QAT, nu facem pur și simplu compromisuri de calitate ca să încapă modelul. Obținem modele proiectate să ruleze mai bine în formate cu biți puțini, îmbunătățind experiența AI locală per ansamblu. În acest test, modelul QAT a fost mai rapid, mai „ușor” și mai plăcut de folosit decât varianta non-QAT.

De-abia aștept să testez versiunea MTP a modelului, care ar putea crește și mai mult viteza, posibil de 2 ori. Asta ar face mult mai ușor să mut o parte mai mare din fluxul meu de lucru pe AI local. Aș putea rula modelul local, să-l conectez cu instrumente precum OpenCode și să încep să editez direct fișierele proiectului cu un asistent local privat.

Acest nou val de AI local schimbă modul în care ne gândim la utilizarea sistemelor AI. Sarcini care odinioară necesitau infrastructuri cloud mari, în special fluxuri multimodale cu intrări text, imagine și video, devin treptat posibile pe mașini locale. Pentru dezvoltatori, cercetători și constructori care pun preț pe confidențialitate, viteză și control, aceasta este o direcție foarte promițătoare.