Presentazione dei Decision Transformers su Hugging Face 🤗

Introducing Decision Transformers on Hugging Face 🤗

A Hugging Face, stiamo contribuendo all’ecosistema per i ricercatori e gli appassionati di Deep Reinforcement Learning. Recentemente, abbiamo integrato framework Deep RL come Stable-Baselines3.

E oggi siamo felici di annunciare che abbiamo integrato il Decision Transformer, un metodo di Offline Reinforcement Learning, nella libreria transformers di 🤗 e nell’Hugging Face Hub. Abbiamo alcuni piani entusiasmanti per migliorare l’accessibilità nel campo del Deep RL e non vediamo l’ora di condividerli con voi nelle prossime settimane e mesi.

• Cos’è l’Offline Reinforcement Learning?
• Introduzione ai Decision Transformers
• Utilizzare il Decision Transformer in 🤗 Transformers
• Conclusioni
• Cosa succederà dopo?
• Riferimenti

Cos’è l’Offline Reinforcement Learning?

Deep Reinforcement Learning (RL) è un framework per costruire agenti decisionali. Questi agenti mirano a imparare un comportamento ottimale (policy) interagendo con l’ambiente attraverso prove ed errori e ricevendo ricompense come feedback unico.

L’obiettivo dell’agente è massimizzare la sua ricompensa cumulativa, chiamata rendimento. Poiché RL si basa sull’ipotesi della ricompensa: tutti gli obiettivi possono essere descritti come la massimizzazione della ricompensa cumulativa attesa.

• ~Non~ Ripeterti
• Habana Labs e Hugging Face si uniscono per accelerare l’addestramento dei modelli Transformer
• Esperti di Machine Learning – Lewis Tunstall

Gli agenti di Deep Reinforcement Learning imparano con batch di esperienza. La domanda è: come la raccolgono?

Un confronto tra Reinforcement Learning in un contesto online e offline, figura tratta da questo post

Nell’apprendimento di rinforzo online, l’agente raccoglie dati direttamente: raccoglie un batch di esperienza interagendo con l’ambiente. Quindi, utilizza immediatamente questa esperienza (o tramite un buffer di replay) per imparare da essa (aggiornare la sua policy).

Ma ciò implica che o addestri direttamente il tuo agente nel mondo reale o hai un simulatore. Se non ne hai uno, devi costruirlo, il che può essere molto complesso (come riflettere la complessa realtà del mondo reale in un ambiente?), costoso e insicuro, poiché se il simulatore presenta difetti, l’agente li sfrutterà se offrono un vantaggio competitivo.

D’altra parte, nell’apprendimento di rinforzo offline, l’agente utilizza solo dati raccolti da altri agenti o dimostrazioni umane. Non interagisce con l’ambiente.

Il processo è il seguente:

1. Crea un dataset utilizzando una o più policy e/o interazioni umane.
2. Esegui l’RL offline su questo dataset per imparare una policy

Questo metodo ha un inconveniente: il problema delle query controfattuali. Cosa facciamo se il nostro agente decide di fare qualcosa per cui non abbiamo dati? Ad esempio, girare a destra in un’intersezione ma non abbiamo questa traiettoria.

Esistono già alcune soluzioni su questo argomento, ma se vuoi saperne di più sull’apprendimento di rinforzo offline puoi guardare questo video

Introduzione ai Decision Transformers

Il modello Decision Transformer è stato introdotto da “Decision Transformer: Reinforcement Learning via Sequence Modeling” di Chen L. et al. Esso astrae l’apprendimento di rinforzo come un problema di modellazione di sequenze condizionale.

L’idea principale è che invece di addestrare una policy utilizzando metodi RL, come adattare una funzione di valore, che ci dirà quale azione intraprendere per massimizzare il rendimento (ricompensa cumulativa), utilizziamo un algoritmo di modellazione di sequenze (Transformer) che, dato un rendimento desiderato, stati passati e azioni, genererà azioni future per raggiungere questo rendimento desiderato. Si tratta di un modello autoregressivo condizionato al rendimento desiderato, agli stati passati e alle azioni per generare azioni future che raggiungano il rendimento desiderato.

Questo è un completo cambiamento nel paradigma dell’apprendimento di rinforzo, poiché utilizziamo la modellazione generativa delle traiettorie (modellazione della distribuzione congiunta della sequenza di stati, azioni e ricompense) per sostituire gli algoritmi RL convenzionali. Significa che nei Decision Transformers non massimizziamo il rendimento, ma generiamo invece una serie di azioni future che raggiungono il rendimento desiderato.

Il processo avviene in questo modo:

1. Alimentiamo gli ultimi K timestep nel Decision Transformer con 3 input:
   • Rendimento da raggiungere
   • Stato
   • Azione
2. I token vengono incorporati con un layer lineare se lo stato è un vettore o un codificatore CNN se sono frame.
3. Gli input vengono elaborati da un modello GPT-2 che predice azioni future tramite modellazione autoregressiva.

Architettura Decision Transformer. Gli stati, le azioni e i rendimenti vengono alimentati nelle incorporazioni lineari specifiche per la modalità e viene aggiunta una codifica temporale episodica posizionale. I token vengono alimentati in un’architettura GPT che predice le azioni in modo autoregressivo utilizzando una maschera di autoattenzione causale. Figura da [1].

Utilizzare il Decision Transformer in 🤗 Transformers

Il modello Decision Transformer è ora disponibile come parte della libreria 🤗 transformers. Inoltre, condividiamo nove checkpoint di modelli pre-allenati per compiti di controllo continuo nell’ambiente Gym.

Un modello “esperto” di Decision Transformers, appreso utilizzando RL offline nell’ambiente Gym Walker2d.

Installazione del pacchetto

pip install git+https://github.com/huggingface/transformers

Caricamento del modello

Utilizzare il Decision Transformer è relativamente semplice, ma essendo un modello autoregressivo, è necessario prestare attenzione per preparare gli input del modello ad ogni passaggio temporale. Abbiamo preparato uno script Python e un notebook Colab che illustrano come utilizzare questo modello.

Caricare un Decision Transformer pre-allenato è semplice nella libreria 🤗 transformers:

from transformers import DecisionTransformerModel

model_name = "edbeeching/decision-transformer-gym-hopper-expert"
model = DecisionTransformerModel.from_pretrained(model_name)

Creazione dell’ambiente

Forniamo checkpoint pre-allenati per Hopper, Walker2D e Halfcheetah in Gym. Presto saranno disponibili checkpoint per gli ambienti Atari.

import gym
env = gym.make("Hopper-v3")
state_dim = env.observation_space.shape[0] # dimensione dello stato
act_dim = env.action_space.shape[0] # dimensione dell'azione

Funzione di previsione autoregressiva

Il modello esegue una previsione autoregressiva; cioè le previsioni fatte al passaggio temporale corrente t sono condizionate in sequenza sugli output dei passaggi precedenti. Questa funzione è piuttosto complessa, quindi cercheremo di spiegarla nei commenti.

# Funzione che ottiene un'azione dal modello utilizzando una previsione autoregressiva
# con una finestra dei 20 passaggi temporali precedenti.
def get_action(model, states, actions, rewards, returns_to_go, timesteps):
    # Questa implementazione non si basa sui premi passati
    
    states = states.reshape(1, -1, model.config.state_dim)
    actions = actions.reshape(1, -1, model.config.act_dim)
    returns_to_go = returns_to_go.reshape(1, -1, 1)
    timesteps = timesteps.reshape(1, -1)
    
    # La previsione è condizionata fino a 20 passaggi temporali precedenti
    states = states[:, -model.config.max_length :]
    actions = actions[:, -model.config.max_length :]
    returns_to_go = returns_to_go[:, -model.config.max_length :]
    timesteps = timesteps[:, -model.config.max_length :]
    
    # riempire tutti i token alla lunghezza della sequenza, ciò è richiesto se elaboriamo batch
    padding = model.config.max_length - states.shape[1]
    attention_mask = torch.cat([torch.zeros(padding), torch.ones(states.shape[1])])
    attention_mask = attention_mask.to(dtype=torch.long).reshape(1, -1)
    states = torch.cat([torch.zeros((1, padding, state_dim)), states], dim=1).float()
    actions = torch.cat([torch.zeros((1, padding, act_dim)), actions], dim=1).float()
    returns_to_go = torch.cat([torch.zeros((1, padding, 1)), returns_to_go], dim=1).float()
    timesteps = torch.cat([torch.zeros((1, padding), dtype=torch.long), timesteps], dim=1)
    
    # eseguire la previsione
    state_preds, action_preds, return_preds = model(
            states=states,
            actions=actions,
            rewards=rewards,
            returns_to_go=returns_to_go,
            timesteps=timesteps,
            attention_mask=attention_mask,
            return_dict=False,)
    return action_preds[0, -1]

Valutazione del modello

Per valutare il modello, abbiamo bisogno di ulteriori informazioni: la media e la deviazione standard degli stati utilizzati durante l’allenamento. Fortunatamente, queste informazioni sono disponibili per ogni modello di checkpoint sulla Hugging Face Hub!

Dobbiamo anche avere un obiettivo di ritorno per il modello. Questo è il potere del Reinforcement Learning Offline condizionato al ritorno: possiamo usare il ritorno target per controllare le prestazioni della politica. Questo potrebbe essere davvero potente in un ambiente multiplayer, dove vorremmo regolare le prestazioni di un bot avversario per farlo avere una difficoltà adatta al giocatore. Gli autori mostrano un ottimo grafico di questo nel loro paper!

Ritorni campionati (valutazione) accumulati da Decision Transformer quando condizionati ai ritorni target specificati. In alto: Atari. In basso: dataset D4RL VoAGI-replay. Figura tratta da [1].

TARGET_RETURN = 3.6 # Questo è stato normalizzato durante l'addestramento
MAX_EPISODE_LENGTH = 1000 

state_mean = np.array(
    [1.3490015,  -0.11208222, -0.5506444,  -0.13188992, -0.00378754,  2.6071432,
     0.02322114, -0.01626922, -0.06840388, -0.05183131,  0.04272673,])

state_std = np.array(
    [0.15980862, 0.0446214,  0.14307782, 0.17629202, 0.5912333,  0.5899924,
         1.5405099,  0.8152689,  2.0173461,  2.4107876,  5.8440027,])

state_mean = torch.from_numpy(state_mean)
state_std = torch.from_numpy(state_std)

state = env.reset()
target_return = torch.tensor(TARGET_RETURN).float().reshape(1, 1)
states = torch.from_numpy(state).reshape(1, state_dim).float()
actions = torch.zeros((0, act_dim)).float()
rewards = torch.zeros(0).float()
timesteps = torch.tensor(0).reshape(1, 1).long()

# Prendi passi nell'ambiente
for t in range(max_ep_len):
    # Aggiungi zeri per le azioni come input per il passo temporale corrente
    actions = torch.cat([actions, torch.zeros((1, act_dim))], dim=0)
    rewards = torch.cat([rewards, torch.zeros(1)])

    # Prevedi l'azione da prendere
    action = get_action(model,
                        (states - state_mean) / state_std,
                        actions,
                        rewards,
                        target_return,
                        timesteps)
    actions[-1] = action
    action = action.detach().numpy()

    # Interagisci con l'ambiente in base a questa azione
    state, reward, done, _ = env.step(action)
    
    cur_state = torch.from_numpy(state).reshape(1, state_dim)
    states = torch.cat([states, cur_state], dim=0)
    rewards[-1] = reward
    
    pred_return = target_return[0, -1] - (reward / scale)
    target_return = torch.cat([target_return, pred_return.reshape(1, 1)], dim=1)
    timesteps = torch.cat([timesteps, torch.ones((1, 1)).long() * (t + 1)], dim=1)
    
    if done:
        break

Troverai un esempio più dettagliato, con la creazione di video dell’agente nel nostro notebook Colab .

Conclusioni

Oltre ai Decision Transformers, vogliamo supportare più casi d’uso e strumenti dalla community del Deep Reinforcement Learning. Pertanto, sarebbe fantastico sentire il tuo feedback sul modello Decision Transformer, e più in generale tutto ciò che possiamo costruire con te che potrebbe essere utile per RL. Sentiti libero di contattarci .

Cosa succederà dopo?

Nelle prossime settimane e mesi, abbiamo intenzione di supportare altri strumenti dell’ecosistema:

• Integrare RL-baselines3-zoo
• Caricare i modelli RL-trained-agents nell’Hub: una grande collezione di agenti di Reinforcement Learning pre-addestrati utilizzando stable-baselines3
• Integrare altre librerie di Deep Reinforcement Learning
• Implementare i Convolutional Decision Transformers per Atari
• E altro ancora 🥳

Il modo migliore per rimanere in contatto è unirsi al nostro server discord per scambiare opinioni con noi e con la community.

Riferimenti

[1] Chen, Lili, et al. “Decision transformer: Reinforcement learning tramite modellazione sequenziale.” Advances in neural information processing systems 34 (2021).

[2] Agarwal, Rishabh, Dale Schuurmans e Mohammad Norouzi. “Una prospettiva ottimistica sull’apprendimento di rinforzo offline.” Conferenza Internazionale su Machine Learning . PMLR, 2020.

Riconoscimenti

Vorremmo ringraziare i primi autori dell’articolo, Kevin Lu e Lili Chen, per le loro costruttive conversazioni.