Salt la conținut

Tokenizatorul, modelul și generarea

ÎncepătorLectură: 4 min

Funcția pipeline de pe pagina anterioară face, pe ascuns, patru lucruri: pune mesajele în formatul de conversație al modelului, transformă textul obținut în tokenuri, generează tokenuri noi și le transformă înapoi în text. Pe această pagină facem pașii unul câte unul. Codul are câteva linii în plus, dar ne permite să controlăm fiecare etapă.

Ghidul oficial care acoperă aceleași subiecte, mai pe larg, este Text generation.

Modelul nu vede litere, ci numere. Tokenizatorul (tokenizer) taie textul în tokenuri și înlocuiește fiecare token cu ID-ul corespunzător din vocabular. Clasele Auto… aleg automat implementarea potrivită pentru modelul cerut.

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("HuggingFaceTB/SmolLM2-360M-Instruct")
ids = tokenizer("Transformers runs language models locally.")["input_ids"]
print("ID-uri: ", ids)
print("Tokenuri:", tokenizer.convert_ids_to_tokens(ids))
print("Înapoi: ", tokenizer.decode(ids))
print("Mărimea vocabularului:", len(tokenizer))
ID-uri: [31806, 366, 7313, 1789, 2859, 10946, 30]
Tokenuri: ['Transform', 'ers', 'Ġruns', 'Ġlanguage', 'Ġmodels', 'Ġlocally', '.']
Înapoi: Transformers runs language models locally.
Mărimea vocabularului: 49152

Caracterul Ġ marchează un spațiu la începutul tokenului. Cuvintele frecvente sunt un singur token, iar cele mai rare se împart în bucăți. Pagina despre modelele de limbaj mari explică de ce, iar laboratorul despre un model de limbaj de la zero construiește un tokenizator simplu de mână.

Codul de mai jos încarcă modelul, construiește promptul unei conversații și generează un răspuns.

from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "HuggingFaceTB/SmolLM2-360M-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, dtype="auto", device_map="auto")
print(f"Dispozitiv: {model.device}, tip de date: {model.dtype}, {model.num_parameters():,} parametri")
messages = [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain in two sentences what a token is."},
]
# Șablonul de chat transformă lista de mesaje în textul exact pe care l-a văzut modelul la antrenare.
print(tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True))
inputs = tokenizer.apply_chat_template(
messages, add_generation_prompt=True, return_dict=True, return_tensors="pt"
).to(model.device)
output = model.generate(**inputs, max_new_tokens=100, do_sample=True, temperature=0.2, top_p=0.9)
# Rezultatul conține și promptul, așa că păstrăm doar tokenurile noi.
new_tokens = output[0, inputs["input_ids"].shape[1]:]
print(tokenizer.decode(new_tokens, skip_special_tokens=True))
Dispozitiv: mps:0, tip de date: torch.bfloat16, 361,821,120 parametri
<|im_start|>system
You are a concise assistant.<|im_end|>
<|im_start|>user
Explain in two sentences what a token is.<|im_end|>
<|im_start|>assistant
A token is a small, often plastic or paper object that is given to a person as a gift or as a reward for a good deed.

Câteva lucruri merită observate.

  • AutoModelForCausalLM încarcă un model de limbaj cauzal (causal language model), adică un model care prezice următorul token pe baza celor anterioare. Argumentul dtype="auto" păstrează tipul de date în care au fost salvate ponderile, aici bfloat16, iar device_map="auto" pune modelul pe placa grafică, dacă există una.
  • Șablonul de chat (chat template) este salvat împreună cu tokenizatorul. Fiecare familie de modele își marchează altfel rolurile. SmolLM2 folosește <|im_start|> și <|im_end|>, iar alte modele au alte tokenuri speciale. Dacă promptul nu respectă exact formatul de la antrenare, răspunsurile devin mult mai slabe. Detaliile sunt în ghidul despre șabloanele de chat.
  • add_generation_prompt=True adaugă la final începutul replicii asistentului, <|im_start|>assistant, ca modelul să continue cu răspunsul, nu cu o nouă întrebare a utilizatorului.
  • Răspunsul este greșit. Modelul a ales sensul de „jeton” al cuvântului token, nu pe cel din informatică. Un model cu 362 de milioane de parametri cunoaște limba destul de bine, dar are puține cunoștințe despre lume. Pagina despre halucinații explică de ce un astfel de răspuns sună totuși atât de sigur.

Metoda generate primește parametrii care controlează alegerea fiecărui token nou.

ParametruCe face
max_new_tokensNumărul maxim de tokenuri generate. Generarea se oprește mai devreme dacă modelul produce tokenul de final.
do_sampleCu False, se alege mereu tokenul cel mai probabil, adică decodare greedy (greedy decoding). Cu True, tokenul este eșantionat din distribuție.
temperatureSub 1, distribuția devine mai ascuțită și răspunsurile mai previzibile. Peste 1, apar mai des tokenuri puțin probabile.
top_p, top_kPăstrează doar tokenurile cele mai probabile înainte de eșantionare.
repetition_penaltyScade probabilitatea tokenurilor care au apărut deja.

Valorile implicite vin din fișierul generation_config.json al modelului. Parametrii trimiși lui generate le înlocuiesc doar pe cele scrise explicit, iar restul rămân cele din fișier. Pagina despre modelele de limbaj mari explică temperatura pe un exemplu, iar ghidul despre strategiile de generare descrie toate opțiunile, inclusiv căutarea pe fascicul (beam search) și decodarea speculativă (speculative decoding).

Asistenții conversaționali afișează textul pe măsură ce apare, nu tot deodată, la final. În Transformers, acest lucru se face cu un TextStreamer. Exemplul de mai jos poartă și o conversație cu două replici.

from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer
model_id = "HuggingFaceTB/SmolLM2-360M-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, dtype="auto", device_map="auto")
# Afișează fiecare bucată de text imediat ce este generată.
streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
messages = []
for question in ["Name three planets.", "Which of them is the largest?"]:
print(f"\n> {question}")
messages.append({"role": "user", "content": question})
inputs = tokenizer.apply_chat_template(
messages, add_generation_prompt=True, return_dict=True, return_tensors="pt"
).to(model.device)
output = model.generate(**inputs, max_new_tokens=80, streamer=streamer)
# Modelul nu ține minte conversația, așa că răspunsul lui intră în istoricul trimis data viitoare.
answer = tokenizer.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
messages.append({"role": "assistant", "content": answer})
> Name three planets.
1. Mercury
2. Venus
3. Earth
> Which of them is the largest?
Venus

Modelul a înțeles că „them” se referă la planetele din răspunsul anterior, pentru că întreaga conversație a fost trimisă din nou în prompt. Exact așa „își amintește” orice asistent conversațional, după cum explică pagina despre memoria agenților. Răspunsul este însă din nou greșit: dintre cele trei, cea mai mare planetă este Pământul. Merită încercate aceleași întrebări și cu un model mai mare, de exemplu Qwen3-1.7B, folosit pe ultima pagină.

Pentru o aplicație web, unde textul trebuie trimis mai departe, nu afișat în terminal, există TextIteratorStreamer, descris în documentația despre streaming.