Skip to content

Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦

C

fix(glm53): --no-think is the template's lowest level, not a shape of ours (#1327)

Vincenzo Fornaro53c57f17ef28
diff --git a/c/deepseek_v4_tiny/.coli_usage b/c/deepseek_v4_tiny/.coli_usage
new file mode 100644
index 00000000..e00fc735
--- /dev/null
+++ b/c/deepseek_v4_tiny/.coli_usage
@@ -0,0 +1,14 @@
+-1 3 4
+-2 1 1277378958
+0 0 78
+0 1 78
+0 2 64
+0 3 64
+1 0 52
+1 1 71
+1 2 61
+1 3 100
+2 0 15
+2 1 41
+2 2 106
+2 3 105
diff --git a/c/deepseek_v4_tiny/config.json b/c/deepseek_v4_tiny/config.json
index c65a4046..332e2af3 100644
--- a/c/deepseek_v4_tiny/config.json
+++ b/c/deepseek_v4_tiny/config.json
@@ -3,7 +3,7 @@
"DeepseekV4ForCausalLM"
],
"model_type": "deepseek_v4",
- "transformers_version": "5.14.1",
+ "transformers_version": "5.12.1",
"torch_dtype": "bfloat16",
"expert_dtype": "fp4",
"scoring_func": "sqrtsoftplus",
diff --git a/c/deepseek_v4_tiny/ref.json b/c/deepseek_v4_tiny/ref.json
index 2011b5d1..dbbdfabb 100644
--- a/c/deepseek_v4_tiny/ref.json
+++ b/c/deepseek_v4_tiny/ref.json
@@ -3,8 +3,8 @@
"generator_version": "2",
"seed": 1234,
"source": "transformers",
- "transformers_version": "5.14.1",
- "torch_version": "2.13.0+cpu",
+ "transformers_version": "5.12.1",
+ "torch_version": "2.12.1+cu130",
"quantization_format": {
"dense": "E4M3 weight + UE8M0 128x128 scale, dequantized in reference",
"routed_experts": "packed E2M1 + UE8M0 per-row/per-32 scale, dequantized in reference",
diff --git a/c/openai_server.py b/c/openai_server.py
index 18fcc390..ebed9d31 100644
--- a/c/openai_server.py
+++ b/c/openai_server.py
@@ -1826,22 +1826,30 @@ def render_chat_glm53(messages, enable_thinking=False, reasoning_effort=None, to
tools = None # il client li ha vietati: non si offrono
prompt = ["[gMASK]<sop>"]
- if enable_thinking:
- # SOLO col ragionamento acceso. Con --no-think il prompt chiude gia' il
- # blocco, e lasciare "Reasoning Effort: Max" davanti a un <think></think>
- # chiuso dice al modello due cose opposte: rifletti al massimo, e hai
- # finito di riflettere. Il modello risponde riaprendo un <think>, lo
- # splitter -- che era partito correttamente in modalita' testo -- lo vede
- # e ci rientra, e da li' in poi tutta la risposta viene archiviata come
- # pensiero: l'utente vede riflettere e poi nessuna risposta (#1278).
- # render_chat (GLM-5.2) mette questa riga sotto la stessa condizione da
- # sempre, ed e' l'unico dei due che non ha mai avuto questa segnalazione.
- #
- # low e high passano, tutto il resto e' Max: e' la scala del template,
- # non la nostra. `none` non arriva qui, spegne il ragionamento a monte.
- effort = {"minimal": "Low", "low": "Low", "medium": "High",
- "high": "High", "xhigh": "Max"}.get(reasoning_effort, "Max")
- prompt.append(f"<|system|>Reasoning Effort: {effort}")
+ # La riga di effort esce SEMPRE, come nel template: `effective_reasoning_effort`
+ # ha un ramo else che vale 'max', quindi non e' mai none. GLM-5.3 non ha un modo
+ # "non ragionare" -- in questo template `enable_thinking` non esiste proprio, e
+ # il prompt di generazione APRE sempre <think>.
+ #
+ # Quindi enable_thinking=False qui non puo' voler dire "spegni": vuol dire "il
+ # minimo che il modello supporta", cioe' Low. Il ragionamento avviene comunque;
+ # a nasconderlo e' il gateway, non il prompt.
+ #
+ # La forma che questo sostituisce -- nessuna riga di effort e <think></think>
+ # chiuso -- non esiste nel template e il modello non l'ha mai vista: e' la causa
+ # di #1278. Meta' di quella deviazione l'ho aggiunta io in #1282, giustificandola
+ # con un meccanismo poi misurato falso e ritirato pubblicamente sulla issue.
+ # Reso il template con jinja2 accanto a questo renderer, l'unica forma che sa
+ # produrre e':
+ # [gMASK]<sop><|system|>Reasoning Effort: {Low|High|Max}<|user|>..<|assistant|><think>
+ #
+ # low e high passano, tutto il resto e' Max: e' la scala del template, non la
+ # nostra. `none` non arriva qui, spegne il ragionamento a monte per le famiglie
+ # che possono davvero spegnerlo.
+ effort = {"minimal": "Low", "low": "Low", "medium": "High",
+ "high": "High", "xhigh": "Max"}.get(reasoning_effort,
+ "Max" if enable_thinking else "Low")
+ prompt.append(f"<|system|>Reasoning Effort: {effort}")
if tools:
prompt.append(_glm53_tool_block(tools))
@@ -1871,17 +1879,13 @@ def render_chat_glm53(messages, enable_thinking=False, reasoning_effort=None, to
else:
raise APIError(400, f"unsupported message role {role!r}.", "messages")
- # Il prompt di generazione apre il blocco di ragionamento; con il
- # ragionamento spento lo chiude subito.
- #
- # Il template ufficiale conosce solo la prima forma, perche' per lui il
- # modello ragiona sempre. La seconda pero' non e' inventata: e' esattamente
- # quello che il template scrive davanti a un turno passato che ragionamento
- # non ne aveva (<think></think> seguito dal contenuto), quindi e' uno stato
- # su cui il modello e' stato addestrato e non una posizione mai vista.
- # Chi vuole il comportamento ufficiale non tocca niente: acceso e' il caso
- # che combacia col template, ed e' quello che il test confronta.
- prompt.append("<|assistant|><think>" if enable_thinking else "<|assistant|><think></think>")
+ # Il prompt di generazione apre il blocco, sempre, come il template:
+ # {%- if add_generation_prompt -%}<|assistant|>{{- '<think>' -}}{%- endif -%}
+ # Il vecchio commento qui sosteneva che <think></think> chiuso fosse "uno stato
+ # su cui il modello e' addestrato" perche' il template lo scrive davanti a un
+ # TURNO PASSATO senza ragionamento. E' vero per un turno passato e falso per il
+ # prompt di generazione: la posizione da cui il modello scrive non e' mai quella.
+ prompt.append("<|assistant|><think>")
return "".join(prompt)
diff --git a/c/tests/test_glm53_chat_template.py b/c/tests/test_glm53_chat_template.py
index c42b4c18..066bff6e 100644
--- a/c/tests/test_glm53_chat_template.py
+++ b/c/tests/test_glm53_chat_template.py
@@ -134,41 +134,41 @@ def main() -> int:
return 1
checked += 1
- # Il ragionamento spento e' una nostra aggiunta: il template non ha quella
- # forma perche' non prevede di spegnerlo. Non e' pero' inventata -- e'
- # quello che il template stesso scrive davanti a un turno passato senza
- # ragionamento -- e va comunque verificata, perche' l'unica cosa che la
- # tiene giusta e' questo controllo.
+ # Il ragionamento "spento" non e' una forma nostra: e' il livello minimo del
+ # template. GLM-5.3 non sa non ragionare -- `effective_reasoning_effort` ha un
+ # ramo else che vale 'max' e non e' mai none, e il prompt di generazione apre
+ # sempre <think>. Quindi enable_thinking=False deve rendere ESATTAMENTE quello
+ # che il template rende con reasoning_effort='low', e questo lo pretende
+ # confrontando i due, non una forma scritta a mano qui.
+ #
+ # La versione precedente di questo blocco pretendeva l'opposto: nessuna riga di
+ # effort e <think></think> chiuso. Era la mia teoria di #1282, misurata falsa e
+ # ritirata su #1278, e il test la teneva in vita: due deviazioni dal template
+ # trasformate in contratto. Un test puo' proteggere un errore tanto quanto una
+ # correttezza -- per questo qui il riferimento e' il template, mai la mia idea
+ # di cosa dovrebbe uscire.
off = openai_server.render_chat_for_arch(
[{"role": "user", "content": "ciao"}], enable_thinking=False)
- on = openai_server.render_chat_for_arch(
- [{"role": "user", "content": "ciao"}], enable_thinking=True)
- if not off.endswith("<|assistant|><think></think>"):
- print(f"FAIL: col ragionamento spento il prompt finisce con {off[-40:]!r}")
+ expected_off = reference(template_text,
+ messages=[{"role": "user", "content": "ciao"}],
+ reasoning_effort="low")
+ if off != expected_off:
+ print("FAIL: col ragionamento al minimo il gateway non rende il template")
+ print(f" gateway: {off!r}")
+ print(f" template: {expected_off!r}")
return 1
- # Questa asserzione prima pretendeva che acceso e spento differissero SOLO
- # per </think>. Era sbagliata, ed e' costata #1278: lasciava "Reasoning
- # Effort: Max" davanti a un blocco gia' chiuso, cioe' diceva al modello di
- # riflettere al massimo e insieme che aveva finito. Il modello riapre un
- # <think>, lo splitter ci rientra e archivia la risposta come pensiero:
- # l'utente vede riflettere e poi niente.
- #
- # Adesso pretende le DUE differenze che devono esserci e nessun'altra: il
- # blocco chiuso, e nessuna riga di effort. E' la stessa forma che
- # render_chat (GLM-5.2) produce da sempre.
- if "Reasoning Effort" in off:
- print("FAIL: col ragionamento spento il prompt chiede ancora di riflettere")
+ if off.endswith("<think></think>"):
+ print("FAIL: e' tornata la forma col blocco chiuso, che il modello non ha "
+ "mai visto in questa posizione (#1278)")
return 1
- stripped = on.replace("[gMASK]<sop>", "", 1)
- stripped = stripped[stripped.index("<|user|>"):] if "<|user|>" in stripped else stripped
- if off[:-len("</think>")] != "[gMASK]<sop>" + stripped:
- print("FAIL: acceso e spento differiscono per piu' della chiusura del blocco "
- "e della riga di effort")
+ if "Reasoning Effort" not in off:
+ print("FAIL: manca la riga di effort, che il template emette sempre (#1278)")
return 1
+ checked += 1
print(f"PASS GLM-5.3 chat template: {checked} rese identiche a "
f"chat_template.jinja, strumenti e livelli di ragionamento compresi, "
- f"piu' la forma col ragionamento spento")
+ f"piu' il livello minimo, che rende come il template con effort low")
return 0