O mulțime de ghiduri vă spun cum să rulati un LLM local. Vi se da o comandă, o lipiți, rulează – și asta este. Dar dacă vrei cu adevărat să înțelegi ce se întâmplă, nu este suficient. Daca ați cumpărat sau închiriat un GPU și meritați să știți tot ce intampla în spatele scenei. Vom explica modul în care funcționează cu adevărat modelele AI pe PC-uri locale.
Ce înseamnă „a rula un model”
Când „rulezi” un model, nu faci magie. Faci ceva numit inferență – în esență, folosind cunoștințele modelului prezici ce urmează într-o propoziție.
prompt = „Cerul este”
ieșire = model.generate (prompt)
Asta este tot ce intampla in procesul de inferenta – prezicerea următoarei bucăți de text. Nici o propoziție completă, nici măcar un cuvânt – doar un simbol. Alege un cuvant pe baza de probabilitate, îl adaugă la textul deja generat, și repetă procesul. Un jeton(token) la un moment dat, iar și iar, până îl oprești.
Așa „vorbește” fiecare model.
Jetoanele (token-urile) nu sunt cuvinte
Un simbol nu este același lucru cu un cuvânt. Este o bucată mică de text – care poate fi un cuvânt întreg, jumătate dintr-un cuvânt sau doar punctuație.
Înainte de începerea modelului, un tokenizer vă împarti textul în aceste bucăți (token-uri). Apoi, le transformă în numere pe care modelul le poate interpreta.
Modelul nu „vede” textul – vede numere.
Și poate afișa doar un număr limitat de token-uri simultan, denumit fereastra de context. (context window). Aceasta este variabila in functie de generația modelului. Ultimele modele au context destul de mare.
Mai multe jetoane = mai multă memorie = mai mult VRAM.
Ce este în interiorul unui model ?
Un model constă din mai multe componente esențiale:
- Greutăți (weights) – miliarde de numere mici care stochează ceea ce a învățat.
- Arhitectura — structura care mișcă acele numere.
- Tokenizer + Config — modul în care textul este împărțit, ce setări utilizează, informații despre licență și așa mai departe.
Când încărcați un model, aceste greutăți sunt transferate în VRAM al GPU-ului. Aceasta este partea principală a memoriei care asigură că totul rulează rapid.
De asemenea, configurează o memorie cache KV – care este ca memoria pe termen scurt a chat-ului dvs. curent. Fiecare token pe care îl trimiteți sau îl primiți rămâne acolo, permițând modelului să țină evidența contextului.
Transformer — adevăratul motor
Nucleul celor mai moderne LLM-uri se numește transform(er) ator. Este un design care gestionează secvențele de text foarte eficient.
Iată ce face, aproximativ:
- Se uită la jetoanele (token-urile) tale.
- Își dă seama care dintre cele anterioare contează cel mai mult (adică atenția de sine).
- Le rulează prin rețele neuronale mici (MLP) pentru a înțelege tiparele.
- Adaugă informații despre poziție, astfel încât să cunoască ordinea jetoanelor (încorporări RoPE).
- Repetă acest lucru pe mai multe straturi – 20, 30, 70, uneori mai mult.
Când modelul generează un nou token, acesta repetă întregul proces.
Fiecare. Singur.
De aceea aveți nevoie de un GPU – este într-adevăr doar o mulțime de matematică făcută rapid.
VRAM – Adevăratul blocaj
VRAM al GPU-ului dvs. incarca două lucruri mari:
- Greutățile (modelul în sine)
- Memoria cache KV (memoria dvs. de conversație)
Iată o idee aproximativă despre cât spațiu are nevoie un model 7B:
| Precizie | VRAM necesar | Note |
| –- | ––– | –––––––– |
| FP16 | ~14GB | Precizie completă |
| INT8 | ~7GB | Echilibru bun |
| INT4 | ~3.5GB | Ideal pentru GPU-uri de consum |
Dacă modelul dvs. nu se va încărca, probabil că este prea mare pentru GPU. Aici intervine cuantificarea (quantization).
Cuantificare (quantization) – Incarcarea modelelor mari în memoria mică
Cuantificarea înseamnă: „stochează numerele modelului cu o precizie mai mică”.
Schimbați un pic de precizie pentru economii semnificative de memorie.
| Format | Biți | Ce înseamnă |
| –– | –– | –––––––– |
| FP16 | 16-biți | Detalii complete |
| INT8 | 8-biți | Jumătate din dimensiune |
| INT4 | 4-biți | Dimensiune sfert, încă bună |
De cele mai multe ori, modelele pe 4 biți funcționează bine. S-ar putea să vedeți greșeli minore în sarcinile de cod sau matematică, dar pentru chat sau scris, sunt excelente.
Cum aleg modelele ce să spună
Modelul nu rostește doar cuvinte. Calculează probabilitățile pentru fiecare potențial jeton următor și apoi alege unul în funcție de setările tale.
Iată butoanele centrale:
- Greedy: alegeți întotdeauna opțiunea de top (sigură, plictisitoare)
- Temperatura: adăugați o oarecare aleatorie (mai mare = mai creativ)
- Top-p/Top-k: limitați cât de vast este grupul de opțiuni
Exemplu:
ieșire = model.generate (prompt, temperatură = 0,8, top_p = 0,9)
Dacă ridici temperatura, vei primi răspunsuri mai ciudate și mai interesante. Coborâți temperatura si modelul devine mai prudent.
Cum îl poți rula
Există câteva modalități de a rula modele la nivel local:
- llama.cpp — mic, rulează aproape oriunde.
- VLLM — foarte rapid, potrivit pentru deservirea mai multor utilizatori.
- ExLlama — excelent pentru modelele în stil Lama.
- Transformers + PyTorch — flexibil, dar greu.
Dacă doriți să vă serviti modelul ca API, este la fel de simplu ca:
from fastapi import FastAPI
from my_model import run_inference
app = FastAPI()
@app.post(„/generate”)
def generate(prompt: str):
return {„response”: run_inference(prompt)}
Boom. Propriul dvs. ChatGPT local. Fără servere, fără jetoane, fără factură lunară.
Greșeli comune
| Problemă | De ce se întâmplă | Remediere rapidă |
| –––- | ––––––– | ––––––– |
| Lipsa memoriei | Modelul prea mare | Cuantizează sau folosește modelul mai mic |
| Răspunsuri greșite | Format de chat greșit | Folosiți șablonul de chat potrivit |
| Prea lent | Rulează pe CPU | Verificați driverele GPU, utilizați CUDA |
Lista de verificare rapidă
- Selectați un model care se potrivește cu capacitatea dvs. VRAM.
- Alegeți cuantificarea (4 biți este punctul dulce).
- Instalați un runtime (llama.cpp sau vLLM).
- Încărcați-l și verificați jetoane/sec.
- Aplicați formatul corect de chat.
- Reglați temperatura și top-p.
- Serviți-l ca API local dacă doriți.