Gauge dependence and structured-output corruption in sign-branched repetition penalties: measurements across models, inference stacks, and alternative repetition controls

Sintesi Tecnica: Dipendenza dal Gauge e Corruzione dell'Output Strutturato nelle Penalità di Ripetizione con Branching del Segno

Enunciato del Problema
Il documento identifica un difetto fondamentale nella penalità di ripetizione moltiplicativa ampiamente distribuita nell'ecosistema dell'inferenza LLM (inclusi Hugging Face, vLLM e llama.cpp). L'operatore standard, ereditato dal modello CTRL, applica una penalità ai token precedentemente visti tramite un branching sul segno dei loro logit grezzi: dividendo i logit positivi per un fattore $\theta$ e moltiplicando quelli negativi per $\theta$.

Il problema centrale è che la posizione dello zero del logit è arbitraria. La funzione softmax è invariante per traslazione ($\text{softmax}(z+c) = \text{softmax}(z)$), il che significa che l'obiettivo di addestramento di un modello vincola la distribuzione di probabilità ma lascia non vincolati i valori assoluti dei logit (il "gauge"). Di conseguenza, il ramo del segno dell'operazione opera su una coordinata che il processo di addestramento non fissa. Ciò porta a due conseguenze negative misurabili:

1. Comportamento Indefinito: Un'impostazione fissa della penalità di ripetizione (ad esempio, $\theta=1.3$) esegue un'operazione matematica differente su modelli diversi (o persino sullo stesso modello con un bias traslato), poiché la frazione di token che ricade sul ramo "divisione" rispetto al ramo "moltiplicazione" varia drasticamente in base allo zero del logit del modello.
2. Corruzione dell'Output Strutturato: La penalità sopprime indiscriminatamente i token richiesti dalla grammatica (ad esempio, le parentesi graffe di chiusura nel JSON, l'indentazione nel codice) semplicemente perché sono già apparsi prima. Ciò causa un calo catastrofico della validità degli output strutturati.

Metodologia
Gli autori conducono una serie di esperimenti controllati su cinque modelli (che vanno da gpt2 a Qwen2.5-7B, inclusi varianti base e RLHF) e due stack di inferenza (vLLM e llama.cpp) per isolare l'effetto del branching del segno.

• Esperimento di Gauge Flip (Conseguenza 1): Gli autori decodificano lo stesso modello due volte con identici seed casuali e input, ma aggiungendo una costante $c$ a tutti i logit (simulando uno spostamento nel bias del modello). Per un intervento ben definito, la selezione greedy del token dovrebbe rimanere identica. Misurano il "tasso di flip" (la frazione di posizioni in cui il token differisce) a $\theta=1.3$ rispetto ai controlli (penalità sottrattive e penalità normalizzate).
• Valutazione dell'Output Strutturato (Conseguenza 2): Gli autori valutano l'impatto della penalità su due compiti:
  • HumanEval: Generazione di codice dove sono richiesti delimitatori specifici.
  • JSONSchemaBench: Generazione di oggetti JSON contro 200 schemi reali.
    Misurano il tasso di output validi e conformi allo schema e la frequza di "flip dei delimitatori" (dove un token strutturale necessario viene erroneamente soppresso).
• Verifica Cross-Stack: Gli esperimenti sono replicati in vLLM e llama.cpp utilizzando i loro sampler nativi per confermare che il problema sia inerente all'implementazione dell'operatore in tutto l'ecosistema.
• Soluzione Proposta: Gli autori testano una variante in cui la penalità viene applicata alle log-probabilità normalizzate ($\log p_i$) anziché ai logit grezzi ($z_i$), eliminando efficacemente il branching del segno poiché tutte le log-probabilità sono non-positive.

Risultati Chiave

• Dipendenza dal Gauge: La standard penalità con branching del segno è altamente sensibile allo zero del logit.
  • Attraverso cinque checkpoint reali, la frazione di token visti con logit positivi (e quindi divisi) varia da 0.17 (gpt2) a 0.95 (Qwen2.5-Coder-7B).
  • Nell'esperimento di flip controllato, spostare lo zero del logit di una costante di $\pm 5$ causa la variazione del 58% al 96% dei token greedy con la penalità standard a $\theta=1.3$. Al contrario, le penalità sottrattive e quelle normalizzate mostrano un tasso di flip dello 0%.
  • Il "costo" dell'intervento (misurato in log-likelihood) varia di un fattore di 4.1 a seconda del gauge, mentre i controlli rimangono costanti.
• Fallimento dell'Output Strutturato: La penalità degrada severamente la generazione strutturata.
  • Su JSONSchemaBench, l'applicazione di $\theta=1.3$ riduce il tasso di output JSON validi dal 97% al 23%.
  • Su HumanEval, la penalità causa flip sui token strutturali con un'accuratezza bilanciata di 0.999 rispetto a una previsione teorica, confermando che il meccanismo è guidato dalla penalità che sopprime i delimitatori necessari.
• Prevalenza nell'Ecosistema: L'implementazione del branching del segno si trova in Hugging Face, vLLM, llama.cpp e altri dodici motori (es. TGI, SGLang, Ollama). Il problema non è isolato a una singola libreria, ma è un artefatto sistemico del design dell'operatore.
• Efficacia della Normalizzazione: Applicare la penalità alle log-probabilità normalizzate ($\log \text{softmax}(z)$) elimina entrambi gli effetti.
  • Il tasso di gauge flip scende a 0.00.
  • La validità JSON a $\theta=1.3$ recupera al 97%.
  • La corruzione dei delimitatori diminuisce di circa 80 volte.

Significatività e Rivendicazioni
Il documento sostiene che la penalità di ripetizione moltiplicativa predefinita non è un "pulito scalare parametro" ma un intervento durante l'inferenza il cui comportamento è parzialmente determinato da un artefatto di addestramento non vincolato (lo zero del logit).

• Mancanza di Portabilità: Un valore $\theta$ fisso non rappresenta la stessa operazione tra diversi modelli, rendendo necessaria la calibrazione per ogni modello e compito.
• Conseguenze Inaspettate: La penalità corrompe l'output strutturato trattando le necessità grammaticali (che devono ripetersi) come ripetizioni indesiderate, un modo di fallimento particolarmente acuto nella generazione di codice e JSON.
• Soluzione: Gli autori dimostrano che normalizzare i logit prima di applicare la penalità (o usare penalità sottrattive) elimina sia la dipendenza dal gauge che la corruzione dell'output strutturato. Notano che Hugging Face spedisce già un operatore LogitNormalization, ma è attualmente disabilitato di default e applicato dopo la penalità, il che non risolve il problema.

Il documento conclude che, sebbene le penalità di ripetizione siano necessari espedienti per il comportamento dei modelli, l'attuale implementazione standard introduce "bordi taglienti" che compromettono l'affidabilità. Gli autori invitano i manutentori degli stack ad adottare la famiglia di penalità sottrattive o a riordinare la penalità moltiplicativa affinché operi sulle log-probabilità normalizzate.