Training di agenti con Reinforcement Learning

Training di agenti con Reinforcement Learning

INDICE Training di agenti con Reinforcement Learning

1. Che cos’e il Reinforcement Learning? Una definizione semplice
2. Perche addestrare gli LLM come agenti autonomi
3. Il processo decisionale con il Markov Decision Process (MDP)
4. I nuovi framework: AgentRL e Agent Lightning
5. Come creare agenti che pianificano, apprendono e migliorano
6. Caso d’uso pratico: addestrare un AI agent con RL in Python
7. Conclusioni: formarsi o soccombere

1. Che cos’e il Reinforcement Learning? Una definizione semplice

Immaginate un bambino che impara a camminare. Non riceve istruzioni scritte su come muovere le gambe: cade, prova di nuovo, e col tempo capisce cosa funziona. Questo e, in sostanza, il Reinforcement Learning (RL), ovvero l’apprendimento per rinforzo.

In termini tecnici, il Reinforcement Learning e un paradigma di machine learning in cui un agente impara a prendere decisioni interagendo con un ambiente. A ogni passo, l’agente si trova in uno stato, compie un’azione, e riceve un segnale di ricompensa (reward) positivo o negativo. L’obiettivo e massimizzare la ricompensa cumulativa nel tempo, imparando quali azioni portano ai risultati migliori.

A differenza del supervised learning, dove il modello impara da esempi gia etichettati, nel RL non c’e un “professore” che dice cosa fare: l’agente esplora, sbaglia, raccoglie feedback dall’ambiente e aggiusta il proprio comportamento. E un approccio che si avvicina molto a come apprendiamo noi esseri umani.

Se vuoi approfondire le basi degli agenti AI, ti consigliamo il Corso Agenti AI ed MCP di Innovaformazione.

2. Perche addestrare gli LLM come agenti autonomi – Training di agenti con Reinforcement Learning

Negli ultimi anni i Large Language Models (LLM) come GPT, Claude e Llama hanno dimostrato capacita sorprendenti nel ragionamento e nella generazione di testo. Tuttavia, usati in modo statico, questi modelli rispondono a un prompt e si fermano. Quando li trasformiamo in agenti AI, li mettiamo in grado di compiere azioni sequenziali: cercare informazioni online, eseguire codice, interagire con API esterne, pianificare passi multipli verso un obiettivo.

Il problema e che gli agenti costruiti con framework tradizionali come LangChain, AutoGen o OpenAI Agents SDK non imparano dall’esperienza. I parametri del modello rimangono fissi, e l’agente commette gli stessi errori ogni volta. Il training con Reinforcement Learning risolve questo limite: invece di limitarsi a eseguire, l’agente raccoglie traiettorie di esperienza, riceve segnali di ricompensa e aggiorna i propri pesi per migliorare nel tempo.

La sfida e che applicare il RL agli agenti LLM e complesso: le interazioni sono multi-turno, i reward spesso arrivano solo a fine episodio, e l’addestramento puo essere instabile. E esattamente qui che entrano in gioco i nuovi framework di ricerca.

3. Il processo decisionale con il Markov Decision Process (MDP)

Per formalizzare il comportamento di un agente, la ricerca utilizza il framework del Markov Decision Process (MDP). Un MDP descrive un problema decisionale attraverso quattro componenti fondamentali.

Spazio degli Stati (S): tutte le situazioni in cui l’agente puo trovarsi. Per un agente LLM, lo stato corrisponde al contesto attuale, ovvero la conversazione in corso, gli output degli strumenti usati, la memoria accumulata.

Spazio delle Azioni (A): tutto cio che l’agente puo fare, come generare testo, chiamare uno strumento o passare al passo successivo di un piano.

Funzione di Transizione (P): descrive come lo stato cambia in seguito a un’azione. Negli ambienti reali questa funzione e stocastica, cioe probabilistica.

Funzione di Reward (R): assegna un punteggio alle transizioni. E il cuore dell’apprendimento: definire bene il reward significa guidare l’agente verso il comportamento desiderato.

Nel contesto degli agenti LLM, l’MDP viene esteso a un POMDP (Partially Observable MDP) perche l’agente non ha una visione completa dell’ambiente. Il paper “The Landscape of Agentic Reinforcement Learning for LLMs” (arXiv, 2025) formalizza proprio questo passaggio, distinguendo i semplici MDP a singolo passo dell’RL classico dagli MDP temporalmente estesi degli agenti autonomi.

L’obiettivo del training con RL e trovare la policy ottimale, ovvero la funzione che, dato uno stato, indica all’agente l’azione migliore per massimizzare il reward atteso nel lungo periodo.

4. I nuovi framework: AgentRL e Agent Lightning

La ricerca del 2025 ha prodotto due framework di riferimento che stanno cambiando le regole del gioco nel training di agenti LLM.

AgentRL (presentato a ICLR 2026 come oral presentation) e un framework multi-task e multi-turno per il training scalabile di agenti LLM. Il suo punto di forza e l’infrastruttura asincrona: la pipeline di generazione e addestramento avviene in parallelo, riducendo i tempi morti tra un rollout e l’altro.

Sul piano algoritmico, AgentRL introduce due innovazioni chiave. La prima e il Cross-Policy Sampling, una strategia che incoraggia l’esplorazione in ambienti multi-turno, evitando che il modello converga su strategie subottimali. La seconda e il Task Advantage Normalization, una tecnica per stabilizzare il training su task eterogenei, bilanciando il segnale di apprendimento tra compiti con reward di scala diversa. I risultati sperimentali su cinque benchmark agentici (ALFWorld, WebShop, Knowledge Graph, OS, Database) mostrano che AgentRL supera modelli closed-source come GPT e Claude-Sonnet, aprendo la strada ad agenti open-source generalisti.

Agent Lightning e il framework open-source sviluppato da Microsoft Research Asia nel 2025. Il suo contributo piu rilevante e un’architettura che separa completamente l’esecuzione dell’agente dall’addestramento del modello, la cosiddetta Training-Agent Disaggregation. In pratica, uno sviluppatore puo prendere un agente gia costruito con LangChain, AutoGen o OpenAI Agents SDK e aggiungere il training con RL modificando pochissime righe di codice.

Il cuore del sistema e LightningRL, un algoritmo gerarchico che scompone le traiettorie dell’agente in transizioni compatibili con gli algoritmi RL standard come GRPO, PPO e REINFORCE++. Un modulo di credit assignment distribuisce il reward sulle singole chiamate LLM all’interno di un episodio, risolvendo uno dei problemi classici del RL multi-turno. Agent Lightning supporta nativamente scenari multi-agente, memory management e workflow dinamici.

Accanto a questi due framework, la comunita scientifica ha prodotto altri contributi rilevanti: AgentGym-RL per il training su task a lungo orizzonte, Agent-R1 per la ricerca su problemi multi-hop QA, e MARTI di Tsinghua University per sistemi multi-agente con ricerca ad albero.

5. Come creare agenti che pianificano, apprendono e migliorano autonomamente

Costruire un agente capace di pianificare e migliorare attraverso il RL richiede di seguire un processo strutturato. Ecco i passaggi fondamentali.

• Passo 1: definizione dell’ambiente e del task. Prima di scrivere una riga di codice, occorre definire chiaramente cosa deve fare l’agente, quali azioni ha a disposizione (tool calling, navigazione web, esecuzione codice) e come misurarne il successo. Questa fase corrisponde alla formalizzazione dell’MDP.
• Passo 2: progettazione del reward. E il punto piu critico dell’intero processo. Il reward deve catturare l’obiettivo vero del task, non un proxy che l’agente potrebbe sfruttare in modo improprio. In un task di risposta a domande, per esempio, il reward puo essere basato sull’accuratezza della risposta finale, su penalita per passi inutili e su bonus per l’uso corretto degli strumenti.
• Passo 3: raccolta delle traiettorie. L’agente interagisce con l’ambiente generando sequenze di stato, azione e reward. Queste traiettorie sono la materia prima dell’apprendimento. Framework come Agent Lightning automatizzano questa fase attraverso un sistema di sidecar che registra l’esecuzione senza interferire con il codice dell’agente.
• Passo 4: aggiornamento della policy. Le traiettorie raccolte vengono usate per aggiornare i pesi del modello tramite algoritmi come GRPO (Group Relative Policy Optimization) o PPO (Proximal Policy Optimization). GRPO e particolarmente popolare in questo contesto perche stima il vantaggio comparando piu campioni dello stesso task, senza richiedere un modello critico separato.
• Passo 5: valutazione e iterazione. Dopo ogni ciclo di training, l’agente viene valutato su un set di test. Se i miglioramenti si confermano, il ciclo continua. Se le prestazioni degradano, occorre rivedere la funzione di reward o la strategia di esplorazione.

6. Caso d’uso pratico: addestrare un AI agent con RL in Python

Vediamo un esempio concreto e funzionante. Simuleremo un agente che risponde a domande usando uno strumento di ricerca, e lo addestreremo con un ciclo RL semplificato basato sull’algoritmo REINFORCE. L’esempio usa un ambiente simulato per rendere il codice eseguibile senza infrastrutture GPU.

Per installare le dipendenze:

pip install torch transformers

Ecco il codice completo:

import random
import torch
import torch.nn as nn
import torch.optim as optim
from transformers import AutoTokenizer, AutoModelForCausalLM

— Ambiente simulato —

L’agente deve rispondere a domande usando uno strumento di ricerca.

Il reward e 1.0 se la risposta e corretta, 0.0 altrimenti.

KNOWLEDGE_BASE = {
"capitale italia": "roma",
"capitale francia": "parigi",
"capitale spagna": "madrid",
"capitale germania": "berlino",
}

def search_tool(query: str) -> str:
"""Simula uno strumento di ricerca su una knowledge base."""
query = query.lower().strip()
return KNOWLEDGE_BASE.get(query, "informazione non trovata")

def compute_reward(agent_answer: str, correct_answer: str) -> float:
"""Calcola il reward confrontando la risposta con quella corretta."""
return 1.0 if agent_answer.lower().strip() == correct_answer.lower().strip() else 0.0
--- Agente RL semplificato ---

class SimpleRLAgent:
def init(self, model_name="gpt2"):
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
self.model = AutoModelForCausalLM.from_pretrained(model_name)
self.optimizer = optim.Adam(self.model.parameters(), lr=1e-5)
if self.tokenizer.pad_token is None:
self.tokenizer.pad_token = self.tokenizer.eos_token

def generate_action(self, state: str, max_new_tokens: int = 20):
    """
    L'agente genera un'azione dato lo stato corrente.
    Restituisce il testo generato e il log-prob per l'aggiornamento RL.
    """
    inputs = self.tokenizer(
        state, return_tensors="pt", truncation=True, max_length=128
    )
    input_ids = inputs["input_ids"]

    with torch.no_grad():
        output = self.model.generate(
            input_ids,
            max_new_tokens=max_new_tokens,
            do_sample=True,       # campionamento stocastico per l'esplorazione
            temperature=0.7,
            pad_token_id=self.tokenizer.eos_token_id
        )

    generated_ids = output[0][input_ids.shape[1]:]
    action_text = self.tokenizer.decode(generated_ids, skip_special_tokens=True)

    # Calcoliamo i log-prob dell'azione per REINFORCE
    outputs = self.model(output[0], labels=output[0])
    log_prob = -outputs.loss

    return action_text.strip(), log_prob

def update_policy(self, log_prob: torch.Tensor, reward: float):
    """
    Aggiornamento REINFORCE: se il reward e alto, aumentiamo la probabilita
    dell'azione compiuta. Il segno meno e necessario per il gradient descent.
    """
    self.optimizer.zero_grad()
    loss = -log_prob * reward
    loss.backward()
    self.optimizer.step()
    return loss.item()

--- Ciclo di training RL ---

def run_training_episode(agent: SimpleRLAgent, question: str, correct_answer: str):
"""
Un singolo episodio: stato -> azione -> strumento -> reward -> aggiornamento policy.
"""
# Step 1: l'agente genera la query per lo strumento di ricerca
state = f"Domanda: {question}\nQuery di ricerca:"
search_query, log_prob_search = agent.generate_action(state, max_new_tokens=10)

# Step 2: l'agente usa lo strumento
search_result = search_tool(search_query)

# Step 3: l'agente genera la risposta finale
state_with_result = (
    f"Domanda: {question}\n"
    f"Risultato ricerca: {search_result}\n"
    f"Risposta:"
)
final_answer, log_prob_answer = agent.generate_action(state_with_result, max_new_tokens=5)

# Step 4: reward e aggiornamento della policy
reward = compute_reward(final_answer, correct_answer)
loss = agent.update_policy(log_prob_answer, reward)

return {
    "question": question,
    "search_query": search_query,
    "search_result": search_result,
    "final_answer": final_answer,
    "correct_answer": correct_answer,
    "reward": reward,
    "loss": loss
}

--- Main ---

def main():
print("Inizializzazione agente RL…")
agent = SimpleRLAgent(model_name="gpt2")

training_data = [
    ("Qual e la capitale dell'Italia?", "roma"),
    ("Qual e la capitale della Francia?", "parigi"),
    ("Qual e la capitale della Spagna?", "madrid"),
    ("Qual e la capitale della Germania?", "berlino"),
]

num_epochs = 3
print(f"\nAvvio training per {num_epochs} epoche...\n")

for epoch in range(num_epochs):
    total_reward = 0.0
    random.shuffle(training_data)

    for question, correct_answer in training_data:
        result = run_training_episode(agent, question, correct_answer)
        total_reward += result["reward"]
        print(
            f"Epoca {epoch+1} | Q: {result['question'][:40]} "
            f"| Risposta: '{result['final_answer']}' "
            f"| Reward: {result['reward']:.1f} "
            f"| Loss: {result['loss']:.4f}"
        )

    avg_reward = total_reward / len(training_data)
    print(f"\n--- Epoca {epoch+1} completata | Reward medio: {avg_reward:.2f} ---\n")

print("Training completato.")

if name == "main":
main()

Questo esempio mostra il ciclo fondamentale del training di agenti con RL: lo stato viene passato all’agente, che genera un’azione, interagisce con uno strumento, riceve un reward e aggiorna i propri parametri. In produzione questo schema viene potenziato con algoritmi piu avanzati come GRPO e PPO, modelli di dimensioni maggiori e infrastrutture distribuite come quelle di AgentRL e Agent Lightning.

7. Conclusioni: formarsi o soccombere

Siamo di fronte a un cambiamento che non ha precedenti nella storia dello sviluppo software. Fino a pochi anni fa, un’applicazione era esattamente cio che il programmatore scriveva: deterministica, prevedibile, statica. Oggi, con gli LLM e gli agenti AI addestrati con Reinforcement Learning, le applicazioni imparano, si adattano e migliorano da sole. Il confine tra software e intelligenza artificiale si sta dissolvendo.

Questo non significa che i developer diventeranno obsoleti. Significa che il ruolo si sta trasformando radicalmente: da chi scrive istruzioni passo per passo a chi progetta ambienti, definisce reward, valuta comportamenti e guida sistemi autonomi verso obiettivi di business. E una transizione enorme, e la velocita con cui avviene non lascia spazio alla passivita.

Per i team di sviluppo, la domanda non e piu “dobbiamo aggiornarci?” ma “quanto velocemente riusciamo a farlo?”. Le aziende che investono oggi nella formazione continua su LLM, agenti AI e tecniche di training come il Reinforcement Learning stanno costruendo un vantaggio competitivo difficile da colmare. Quelle che aspettano rischiano di trovarsi con un team che non parla piu la lingua del software moderno.

Se vuoi portare il tuo team al passo con questa rivoluzione, Innovaformazione offre il Corso Sviluppo Applicazioni LLM, rivolto alle aziende e svolto in modalita online con classe virtuale. Il calendario e concordabile in base alle esigenze del tuo team, i contenuti e le esercitazioni sono personalizzabili sul contesto specifico della tua organizzazione, e i partecipanti lavorano su casi d’uso reali:

Corso Sviluppo Applicazioni LLM

Non aspettare che il divario diventi incolmabile. La formazione non e un costo: e l’unico investimento che produce valore in modo esponenziale nel tempo.

Contatti:

• email: info@innovaformazione.net
• TEL. 3471012275 (Dario Carrassi)

(fonte) (fonte) (fonte) (fonte)

Per altri articoli di settore consigliamo di navigare sul nostro blog QUI.