Introduzione al problema agentico multi‑turn

Nei precedenti articoli “Easy Function Gemma finetuning with Tunix on Google TPUs” e “Autonomous LLM post‑training with Tunix on TPUs” è stato mostrato come Tunix semplifichi il Supervised Fine‑Tuning (SFT) e il Group Relative Policy Optimization (GRPO) a turno singolo sulle Cloud TPU. Tuttavia, gli agenti reali raramente completano il loro compito in un unico turno: devono ragionare su osservazioni parziali, invocare strumenti, osservare il feedback dell’ambiente e adattare la strategia in più passaggi.

Questo articolo descrive passo passo come addestrare un agente LLM multi‑turn, capace di usare strumenti, sfruttando la pipeline di reinforcement learning agentico di Tunix su una TPU v6e‑8. Il codice completo è disponibile nel repository GitHub indicato.

Il gioco di riferimento: Plane Strike

Plane Strike è un gioco da tavolo a griglia 6 × 6 (celle da A1 a F6) in cui un aereo di 8 celle è nascosto in una delle quattro possibili orientazioni. Le regole sono le seguenti:

    • Ad ogni turno l’agente osserva il risultato del colpo precedente e la griglia visibile (simboli .untried, Xhit, Omiss).
    • L’agente ragiona su possibili posizioni dell’aereo e chiama lo strumento strike(cell="...") per colpire una cella.
    • Il gioco termina quando tutte le 8 celle dell’aereo sono colpite oppure dopo 23 colpi.

Con Gemma 4‑E2B in modalità “thinking” su una singola TPU v6e‑8, il modello dimostra buone capacità di ragionamento spaziale e chiamata di strumenti, ma la sua percentuale di vittorie sui board di test è solo del 9,4 % (media di 22,44 colpi per partita).

Miglioramento con GRPO agentico

Dopo 100 step di agentic GRPO con Tunix, il tasso di vittorie sale al 95 % e la durata media della partita si riduce a circa 16 colpi.

Componenti modulari della pipeline RL multi‑turn

La pipeline è organizzata in quattro componenti principali:

    • Inenv.py: sottoclasse di BaseTaskEnv di Tunix per implementare PlaneStrikeEnv. Ogni istanza riceve un dizionario di task con un seed che fissa la posizione dell’aereo, garantendo che tutti gli 8 rollout di un gruppo GRPO giochino sullo stesso board.
    • strike_tool.py: definisce StrikeTool(BaseTool) e estende Gemma4ChatTemplateParser per aggiungere la dichiarazione dello strumento al system prompt e renderizzare i messaggi “tool” come risposte in‑turno.
    • agent.py: PlaneStrikeAgent(ConversationAgentBase) traduce le osservazioni dell’ambiente in messaggi per il modello e viceversa.
    • train_planestrike.py: configura il motore di rollout asincrono vllm (RLEngine) e il GRPOLearner.

Gestione degli strumenti in Gemma 4

Le schede degli strumenti sono dichiarate all’interno del system prompt usando la sintassi <|tool>declaration:...<tool|>. Un turno del modello che chiama uno strumento termina con il token di stop nativo <|toolresponse>, seguito da una risposta del tipo strike{value:<"...>}. Il modello si mette in pausa in <|toolresponse> e attende la risposta dallo strumento prima di continuare a generare il pensiero successivo.

Implementazione dell’ambiente Plane Strike

Nel file Inenv.py il metodo stepimpl esegue le seguenti operazioni:

    • Valuta l’indice della cella colpita rispetto alla griglia nascosta.
    • Aggiorna la griglia visibile con i simboli appropriati.
    • Calcola la ricompensa del passo (sommandola al reward della traiettoria).
    • Restituisce EnvStepResult(observation, reward, done, info).

Per agenti multi‑tool, la libreria tunix.rl.agentic fornisce già le astrazioni ToolEnvironment, ToolAgent e ToolManager, eliminando la necessità di scrivere codice di plumbing personalizzato, a meno che non si richieda un controllo di turno su misura.

Parsing delle risposte di Gemma 4

Quando il modello termina un turno, toolstrike ignora tutto ciò che è contenuto tra <|channel>thought...<channel|> e analizza la risposta finale dopo <channel|>. Solo una risposta con una singola chiamata di strike valida viene accettata; altrimenti viene restituito INVALIDACTION. Se il modello si ferma a <|tool_response>, la successiva osservazione della board viene aggiunta con role="tool" così il modello continua nello stesso turno.

Configurazione del motore di rollout e del learner

Nel file train_planestrike.py si impostano i seguenti parametri chiave:

    • rolloutvllmserver_mode = true: abilita roll‑out multi‑turn asincroni continui tramite vllm‑tpu.
    • enableprefixcaching = true: memorizza nella cache la cronologia della conversazione per ridurre il ricalcolo dei token.
    • Il modello attore, il modello di riferimento e i worker di rollout condividono le 8 chip della TPU v6e‑8.
    • Passiamo a RLEngine e PlaneStrikeGRPOLearner i seguenti oggetti: attore, tokenizer, ClusterConfig, GRPOConfig (con lossalgo="gspo-token", advantageestimator="rloo", exacttokencontinuity=True), agente e ambiente.

Queste impostazioni preservano gli ID dei token esatti attraverso i roll‑out multi‑turn, evitando drift di retokenizzazione.

Esecuzione del job di addestramento

Il comando di lancio sintetico è:

python trainplanestrike.py --steps=100 --boards=8 --gamesper_step=8

Con 100 step (8 board × 8 partite per step) l’agente apprende sia una chiamata di strumento affidabile sia una deduzione spaziale efficace.

Risultati e conclusioni

Dopo l’addestramento, le metriche chiave sono:

    • Win rate: 95 % (vs. 9,4 % iniziale).
    • Numero medio di colpi per partita: ≈ 16 (vs. 22,44 iniziali).

Questo dimostra che, con le astrazioni agentiche di Tunix, vllm‑tpu e il learner GRPO, è possibile eseguire reinforcement learning agentico multi‑turn con uso di strumenti in modo semplice ed efficiente su Cloud TPU.

Risorse aggiuntive

    • Articoli correlati: “Agent Anomaly Detection: Safeguarding agents across other clouds”, “Unlocking Stable On‑Policy RL on TPU with Bitwise‑Zero Train–Inference Mismatch”, “Securing Your Agents: A Hands‑On Guide to Agent Anomaly Detection”.

Con questi strumenti a disposizione, gli sviluppatori possono sperimentare e addestrare i propri agenti LLM agentici su TPU, estendendo il paradigma a domini più complessi e a scenari di tool‑calling avanzati.