...
← Curs Aplicații AI cu Claude și OpenAI: toate lecțiile
Lecția 5 · Cum funcționează LLM-urile

Temperatura și de ce răspunsurile diferă

Pune aceeași întrebare de două ori unui model și vei primi, de obicei, două formulări diferite. În spate este eșantionarea din lecția 2, reglată în trecut printr-un parametru numit temperatură. În această lecție înțelegi ce face temperatura, afli de ce API-ul Claude actual nu o mai acceptă și înveți ce folosești în locul ei: instrucțiuni clare și parametrul effort.

De unde vine variația

Ai văzut în lecția 2 că modelul calculează probabilități pentru următorul token și apoi alege unul, ponderat. Pentru fiecare variantă posibilă modelul produce de fapt un scor; scorurile sunt transformate în probabilități, iar temperatura este numărul cu care se împart scorurile înainte de transformare.

  • Temperatură mică (de exemplu 0,2): varianta cea mai probabilă devine aproape sigură. Răspunsuri previzibile, repetabile.
  • Temperatură 1: probabilitățile învățate de model, neschimbate.
  • Temperatură mare (peste 1): variantele rare primesc mai multe șanse. Mai multă creativitate, dar și mai multe ciudățenii.

Calculul, în Python

Transformarea scorurilor în probabilități se numește softmax: ridici e la puterea fiecărui scor împărțit la temperatură și împarți la suma tuturor. Cu aceleași scoruri ca în vizualizarea de mai sus:

import math

# scorurile modelului pentru următorul cuvânt după „Cel mai bun limbaj pentru începători este”
scoruri = {"Python": 4.0, "JavaScript": 2.6, "Scratch": 1.6, "C": 0.6}


def probabilitati(scoruri, temperatura):
    exp = {cuv: math.exp(s / temperatura) for cuv, s in scoruri.items()}
    total = sum(exp.values())
    return {cuv: v / total for cuv, v in exp.items()}


for t in [0.5, 1.0, 1.5]:
    p = probabilitati(scoruri, t)
    linie = ", ".join(f"{cuv} {v:.2f}" for cuv, v in p.items())
    print(f"T={t}: {linie}")
T=0.5: Python 0.93, JavaScript 0.06, Scratch 0.01, C 0.00
T=1.0: Python 0.73, JavaScript 0.18, Scratch 0.07, C 0.02
T=1.5: Python 0.59, JavaScript 0.23, Scratch 0.12, C 0.06
Temperatură 0,5Python0,93JavaScript0,06Scratch0,01C0,00Temperatură 1,0Python0,73JavaScript0,18Scratch0,07C0,02Temperatură 1,5Python0,59JavaScript0,23Scratch0,12C0,06aproape mereu Pythondistribuția învățatămai multă varietateAceleași scoruri, temperaturi diferite: cu cât e mai mare, cu atât variantele rare au mai multe șanse.
Distribuția următorului cuvânt pentru aceleași scoruri la trei temperaturi: la 0,5 aproape mereu iese Python, la 1,5 celelalte variante apar mult mai des.

Important: API-ul Claude nu mai acceptă temperature

Multe tutoriale vechi trimit temperature=0.2 sau top_p. La modelele Claude actuale (versiunea API 2026-10-21) acești parametri nu mai sunt acceptați: temperature, top_p și top_k au fost scoși. Stilul și calitatea răspunsului se controlează acum altfel, cum vezi mai jos.

import anthropic

client = anthropic.Anthropic()

raspuns = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=200,
    temperature=0.2,          # NU mai este acceptat
    messages=[{"role": "user", "content": "Rezumă politica de retur."}],
)

Codul de mai sus se oprește imediat: SDK-ul Python aruncă TypeError cu mesajul unexpected keyword argument 'temperature', înainte să trimită ceva. Dacă trimiți parametrul direct prin HTTP, API-ul răspunde cu eroarea 400 (cerere invalidă). La fel se întâmplă la modelele de raționament ale OpenAI: și ele resping temperature.

Atenție la codul copiat

Când iei exemple de pe internet sau de la un asistent AI antrenat pe cod vechi, șterge temperature, top_p și top_k din apelurile către modelele actuale. Este una dintre cele mai frecvente erori la migrarea unei aplicații.

Ce folosești în loc: instrucțiuni și effort

Stilul răspunsului îl controlezi acum prin două mijloace. Primul sunt instrucțiunile: „răspunde în 2 fraze, ton formal” sau „propune 3 variante cu tonuri diferite” fac mai mult decât orice temperatură. Al doilea este parametrul effort, dat prin output_config, care spune cât de mult să „gândească” modelul înainte să răspundă:

ValoareCând o folosești
lowsarcini simple și dese: clasificări, rezumate scurte, extragere de date; cel mai rapid și mai ieftin
mediumvaloarea implicită la Claude Haiku 5.5; echilibru bun pentru majoritatea aplicațiilor
highsarcini grele: planuri, analize, cod, raționamente în mai mulți pași
xhigh, maxcele mai dificile probleme, când calitatea contează mai mult decât timpul și costul
import anthropic

MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()

POLITICA = "Produsele nefolosite, în ambalajul original, se pot returna în 30 de zile. Banii se întorc în 5 zile lucrătoare."

raspuns = client.messages.create(
    model=MODEL,
    max_tokens=300,
    output_config={"effort": "low"},   # sarcină simplă: efort mic, rapid și ieftin
    messages=[{"role": "user", "content": f"Rezumă în 2 fraze, pentru un client, politica de retur:\n{POLITICA}"}],
)
print(raspuns.content[0].text)
print("Tokeni ieșire:", raspuns.usage.output_tokens)
Poți returna produsul în 30 de zile, nefolosit și în ambalajul original. Banii ajung înapoi în 5 zile lucrătoare.
Tokeni ieșire: 35

Un efort mai mare înseamnă de obicei mai mult raționament și răspunsuri mai temeinice, deci mai mulți tokeni de ieșire: mai scump și mai lent. Alegi efortul după sarcină, nu „cât mai mare, ca să fie sigur”.

Valori greșite

output_config={"effort": "mic"} dă eroarea 400 output_config.effort: Input should be 'low', 'medium', 'high', 'xhigh' or 'max'. Valorile sunt fixe, în engleză.

Variație sau consecvență: ce vrei în aplicație

Când ai nevoie de variante (sloganuri, idei, titluri), nu face 3 apeluri sperând la răspunsuri diferite: cere-le explicit într-un singur apel și desparte-le în cod.

import anthropic

MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()

raspuns = client.messages.create(
    model=MODEL,
    max_tokens=300,
    messages=[{"role": "user", "content": "Propune 3 variante diferite de slogan pentru o cafenea de cartier, una pe linie, fiecare cu alt ton."}],
)
variante = raspuns.content[0].text.split("\n")
print("Am primit", len(variante), "variante:")
for v in variante:
    print(" ", v)
Am primit 3 variante:
  1. Cafea bună, oameni buni, colțul tău de liniște.
  2. Dimineața începe la noi.
  3. Prăjită aproape, servită cu zâmbet.

Când ai nevoie de consecvență (clasificări, extragere de date, răspunsuri de suport), nu te baza pe noroc:

  • Instrucțiuni precise și exemple de răspuns (modulul 2).
  • Format fix, de exemplu JSON cu schemă, pe care îl verifici în cod (lecțiile 13 și 14).
  • Pentru întrebări identice și dese (de exemplu „Care e programul?”), salvezi răspunsul aprobat și nu mai apelezi modelul.
  • În teste verifici conținutul (cuvinte cheie, câmpuri), nu textul exact, pentru că formularea poate varia.
MarketingIdei de postări

Un singur apel cere 5 variante cu tonuri diferite; omul alege una.

BancăClasificarea tranzacțiilor

Efort low, categorii fixe, răspuns verificat în cod: același rezultat la fiecare rulare.

LogisticăPlanificarea rutelor

Efort high, pentru că o greșeală costă mai mult decât câțiva tokeni în plus.

Exercițiul tău

Compară costul în tokeni al aceleiași cereri cu efort diferit. Trimite CERERE o dată cu output_config={"effort": "low"} și o dată cu output_config={"effort": "high"}, afișează pentru fiecare Efort low: N tokeni de ieșire și Efort high: M tokeni de ieșire, apoi textul răspunsului cu efort high.

  • Trimite cererea cu client.messages.create, max_tokens=1000 și output_config={"effort": "low"}, apoi cu "high" (o buclă for efort in ["low", "high"] e cea mai simplă).
  • Citește tokenii de ieșire din raspuns.usage.output_tokens.
  • Afișează Efort low: N tokeni de ieșire și Efort high: M tokeni de ieșire, în această ordine.
  • Afișează la final textul răspunsului cu efort high.
Păstrează răspunsurile într-un dicționar, raspunsuri[efort] = raspuns, ca să poți afișa la final raspunsuri["high"].content[0].text.

Soluția exercițiului

import anthropic

MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()

CERERE = "Propune un plan pentru inventarul lunar al unui magazin mic."

raspunsuri = {}
for efort in ["low", "high"]:
    raspuns = client.messages.create(
        model=MODEL,
        max_tokens=1000,
        output_config={"effort": efort},
        messages=[{"role": "user", "content": CERERE}],
    )
    raspunsuri[efort] = raspuns
    print(f"Efort {efort}: {raspuns.usage.output_tokens} tokeni de ieșire")

print(raspunsuri["high"].content[0].text)
Excelent! Continuă cu lecția următoare →
main.pyPython
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Cum funcționează LLM-urile Lecția 5 · Temperatura și de ce răspunsurile diferă
Progres 0% 0 din 10
Lecția curentă 5 / 8 Cum funcționează llm-urile