Ottimizzare un modello da 350M per output strutturati in 100 passaggi GRPO

Ricetta economica per output strutturati affidabili

Questo articolo illustra una guida completamente pubblica e accessibile per migliorare sostanzialmente la capacità di un modello linguistico di piccole dimensioni nel rispettare i vincoli di output strutturato. L'approccio si basa sulla fine-tunizzazione del modello LFM2.5-350M mediante Group Relative Policy Optimization (GRPO), utilizzando la libreria TRL e valutandolo sul benchmark IFStruct. L'intera procedura richiede circa 500 campioni e 100 passaggi di addestramento, sufficientemente leggera per essere eseguita su GPU gratuiti da Colab o Kaggle, con il codice completo disponibile su GitHub.

I risultati ottenuti sono particolarmente incoraggianti: la procedura di fine-tunizzazione leggera migliora le prestazioni dal 22,6% al 29,7% sul benchmark IFStruct. Questo rappresenta un progresso significativo che dimostra come anche piccoli modelli, con l'ottimizzazione giusta, possono raggiungere livelli di performance comparabili a modelli considerevolmente più grandi.

L'importanza degli output strutturati nel mondo reale

L'output strutturato è uno dei compiti più comuni nel mondo reale per i modelli linguistici di grandi dimensioni, eppure la maggior parte dei benchmark lo incorpora in punteggi di ragionamento o estrazione più ampi, anziché misurarlo singolarmente. Ciò che effettivamente conta nella pratica è se un modello restituisce in modo affidabile output validi e analizzabili nel formato e nella forma richiesti — quello che viene chiamato schema compliance. È precisamente questa capacità che determina se un modello può essere integrato in un sistema downstream, cioè se può effettivamente funzionare all'interno di una pipeline di produzione.

Questa distinzione è fondamentale perché nella pratica industriale, un modello che produce output valido dal punto di vista semantico ma non conforme allo schema richiesto è sostanzialmente inutilizzabile. Se un sistema si aspetta un JSON valido con campi specifici e il modello produce una risposta che non è JSON o contiene campi mancanti, l'intera pipeline fallisce. Ecco perché la conformità allo schema non è un elemento secondario ma una questione di importanza critica per il deployment.

Nota sulla metodologia e gli obiettivi

È importante precisare che la pipeline di addestramento descritta in questa guida non è quella utilizzata per addestrare il modello RL descritto nel blog di IFStruct. Questo notebook non mira a ricreeare il punteggio esatto del benchmark IFStruct, ma piuttosto a dimostrare come la fine-tunizzazione task-specifica di modelli più piccoli possa migliorare significativamente le prestazioni e avvicinarsi a quella di modelli molto più grandi. Questo approccio è particolarmente prezioso per chi lavora con risorse computazionali limitate ma necessita di modelli affidabili per compiti specifici.

Struttura della guida e componenti necessari

La guida è strutturata in due parti che si eseguono in ambienti diversi. Per l'implementazione, sono necessari alcuni strumenti fondamentali: uv per gli strumenti Python e llama.cpp per il serving del modello. Seguendo la documentazione ufficiale di Liquid AI per la distribuzione con llama.cpp, è necessario installare llama.cpp con Homebrew e verificare che llama-server sia disponibile nel sistema.

Questa struttura modulare consente agli utenti di eseguire la valutazione e l'addestramento in ambienti diversi — per esempio, la valutazione su una macchina locale e l'addestramento su cloud GPU — mantenendo comunque la compatibilità completa tra gli ambienti.

Valutazione della baseline con IFStruct

Prima di procedere con la fine-tunizzazione, è essenziale valutare le prestazioni di base del modello LFM2.5-350M sul benchmark IFStruct e verificare se è possibile riprodurre il punteggio riportato del 21,1%. IFStruct è un benchmark specializzato per testare la validità degli output dei modelli linguistici e l'aderenza allo schema. Il benchmark è open-source nel repository Liquid4All/ifstruct, con il dataset pubblico del benchmark disponibile su Hugging Face presso LiquidAI/ifstruct-v1.0.

Per il confronto della valutazione, il modello viene servito localmente su una MacBook con llama.cpp, utilizzando il file BF16 GGUF (LiquidAI/LFM2.5-350M-GGUF). Il blog di rilascio di IFStruct riporta un 21,1% per LFM2.5-350M. La configurazione locale con llama.cpp/BF16 misura il 22,6%, molto vicino al 21,1% riportato nel blog IFStruct. Questo risultato locale viene utilizzato come baseline per il confronto sulla stessa stack di serving.

Preparazione dei dati di addestramento

La pipeline completa e runnable risiede nel notebook accompagnatore. Per l'addestramento, viene utilizzato il dataset nvidia/Nemotron-RL-instruction_following-structured_outputs, che abbina ogni prompt a uno schema JSON target e a un numero di campi previsto. Complessivamente, vengono utilizzati circa 500 campioni per l'addestramento.

Dato che la distribuzione dei dati di Nemotron differisce dalla valutazione IFStruct, i prompt vengono aumentati per colmare due lacune importanti tra loro. Questo step di data augmentation è cruciale per assicurare che il modello fine-tunizzato generalizzi bene sul benchmark di valutazione.

Configurazione dell'adattatore LoRA e targeting dei moduli

Il modello LiquidAI/LFM2.5-350M viene caricato e vi viene allegato un adattatore LoRA. Poiché LFM2.5 utilizza un'architettura ibrida di attenzione e convoluzione, vengono presi di mira i nomi specifici dei moduli LFM. Questo approccio risulta nell'addestramento di circa 6 milioni di parametri, equivalenti all'1,66% del modello. Questa strategia consente di ridurre significativamente il costo computazionale dell'addestramento mantenendo un'efficacia notevole.

Definizione delle funzioni di reward

Il sistema di reward è definito mediante tre funzioni di reward distinte, ciascuna su una scala [0, 1], che valutano ogni completamento in base a se la struttura estratta è corretta:

• Validità JSON: verifica se l'output è un JSON valido secondo le specifiche
• Conformità dello schema: controlla se i campi e i tipi corrispondono allo schema previsto
• Completezza dei campi: assicura che tutti i campi obbligatori siano presenti nella risposta

Queste tre funzioni vengono combinate come somma ponderata con reward_weights=[1.0, 0.5, 2.0], attribuendo maggior peso alla completezza dei campi. Questa ponderazione riflette il fatto che nella pratica, un output incompleto è spesso più problematico di uno che non è perfettamente valido dal punto di vista della formattazione.

Procedura di addestramento GRPO

L'addestramento procede per 100 passaggi con 8 generazioni per gruppo di prompt, dimensionato per funzionare su una GPU gratuita da 16 GB. Durante l'esecuzione della procedura, tutti e tre i componenti di reward aumentano, la divergenza KL dal modello di riferimento si attiva dopo il riscaldamento (warmup), e la frazione di completamenti troncati rimane vicina a zero. Questi indicatori suggeriscono che l'addestramento sta procedendo in modo stabile e controllato.

Una volta completato l'addestramento GRPO, l'adattatore LoRA viene unito nuovamente ai pesi di base e salvato come un checkpoint autoportante e singolo, pronto per essere convertito in GGUF per il serving. Questo processo di merge è importante perché crea un modello che può essere distribuito senza necessità di caricamenti aggiuntivi di adattatori.

Conversione a GGUF e nuova valutazione

Dopo la fine-tunizzazione GRPO, la valutazione di IFStruct viene rieseguita con il modello fine-tunizzato. Per questo, è necessario convertire il checkpoint unito in BF16 GGUF. Lo script di conversione è fornito con il sorgente di llama.cpp, quindi il repository viene clonato una volta e viene installato il pacchetto gguf del convertitore.

Il modello unito viene quindi servito con un comando simile a quello della baseline, e la valutazione IFStruct completa viene eseguita di nuovo. I confronti tra i due esecuzioni sulla stessa stack di serving rivelano miglioramenti significativi e targettizzati.

Risultati e analisi delle performance

I guadagni ottenuti si collocano esattamente dove l'addestramento mirava: il tasso di successo JSON aumenta di quasi 14 punti (dal 18,0% al 31,9%), mentre YAML rimane sostanzialmente uguale. Sebbene il risultato sia ancora al di sotto del punteggio di Qwen3.5-2B pari a 33,15%, dimostra che anche una fine-tunizzazione task-specifica leggera può portare un modello piccolo molto vicino a uno più grande. Inoltre, il modello fine-tunizzato raggiunge un punteggio complessivo del 29,7%, un miglioramento significativo dal baseline del 22,6%.

Questi risultati sono particolarmente notevoli considerando il costo computazionale minimo e la semplicità della procedura. Una breve esecuzione di GRPO con circa 500 campioni e 100 passaggi può portare un modello piccolo da 350M parametri dal 22,6% al 29,7% su IFStruct. L'insegnamento principale è che un segnale di reward task-specifico economico può rendere un modello piccolo sostanzialmente più affidabile nella forma, colmando gran parte del divario rispetto a modelli diversi volte più grandi.

Conclusioni e risorse per ulteriori sviluppi

Questa guida dimostra che non è necessario disporre di enormi risorse computazionali o modelli massicciamente grandi per ottenere output affidabili e conformi allo schema. Con la giusta strategia di fine-tunizzazione e un segnale di reward ben progettato, anche modelli compatti possono raggiungere livelli di performance sorprendentemente alti. Questo ha implicazioni significative per il deployment di modelli linguistici in ambienti dove le risorse sono limitate ma l'affidabilità è critica.

Per chi desideri riprodurre o estendere questo lavoro, le risorse disponibili includono il post blog originale di IFStruct v1.0, il repository del benchmark Liquid4All/ifstruct, e il dataset LiquidAI/ifstruct-v1.0. Tutti questi sono open-source e accessibili pubblicamente, rendendo facile per i ricercatori e i practitioner sperimentare e costruire su questa fondazione.