# Decision Transformer

## Aperçu

Le modèle Decision Transformer a été proposé dans [Decision Transformer: Reinforcement Learning via Sequence Modeling](https://huggingface.co/papers/2106.01345) par Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, Igor Mordatch.

L'abstract de l'article est le suivant :

*Nous présentons un cadre qui abstrait l'apprentissage par renforcement (RL) comme un problème de modélisation de séquences. Cela nous permet de tirer parti de la simplicité et de l'évolutivité de l'architecture Transformer, ainsi que des avancées associées en modélisation de langage, telles que GPT-x et BERT. En particulier, nous présentons Decision Transformer, une architecture qui reformule le problème de RL comme une modélisation de séquences conditionnelle. Contrairement aux approches antérieures de RL qui ajustent des fonctions de valeur ou calculent des gradients de politique, Decision Transformer produit simplement les actions optimales en s'appuyant sur un Transformer masqué de manière causale. En conditionnant un modèle autorégressif sur le retour (récompense) souhaité, les états passés et les actions, notre modèle Decision Transformer peut générer des actions futures qui atteignent le retour souhaité. Malgré sa simplicité, Decision Transformer égale ou surpasse les performances des références de RL hors ligne sans modèle de l'état de l'art sur les tâches Atari, OpenAI Gym et Key-to-Door.*

Cette version du modèle est destinée aux tâches où l'état est un vecteur.

Ce modèle a été contribué par [edbeeching](https://huggingface.co/edbeeching). Le code d'origine peut être trouvé [ici](https://github.com/kzl/decision-transformer).

## DecisionTransformerConfig[[transformers.DecisionTransformerConfig]]

#### transformers.DecisionTransformerConfig[[transformers.DecisionTransformerConfig]]

```python
transformers.DecisionTransformerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, state_dim: int = 17, act_dim: int = 4, hidden_size: int = 128, max_ep_len: int = 4096, action_tanh: bool = True, vocab_size: int = 1, n_positions: int = 1024, n_layer: int = 3, n_head: int = 1, n_inner: int | None = None, activation_function: str = 'relu', resid_pdrop: float | int = 0.1, embd_pdrop: float | int = 0.1, attn_pdrop: float | int = 0.1, layer_norm_epsilon: float = 1e-05, initializer_range: float = 0.02, scale_attn_weights: bool = True, use_cache: bool = True, bos_token_id: int | None = 50256, eos_token_id: int | list[int] | None = 50256, scale_attn_by_inverse_layer_idx: bool = False, reorder_and_upcast_attn: bool = False, add_cross_attention: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/decision_transformer/configuration_decision_transformer.py#L24)

**Paramètres :**

state_dim (`int`, *facultatif*, valeur par défaut : 17) : La taille de l'état pour l'environnement RL

act_dim (`int`, *facultatif*, par défaut 4) : La taille de l'espace d'actions de sortie

hidden_size (`int`, *facultatif*, par défaut `128`) : Dimension des représentations cachées.

max_ep_len (`int`, *facultatif*, valeur par défaut : 4096) : La longueur maximale d'un épisode dans l'environnement

action_tanh (`bool`, *facultatif*, par défaut True) : Indique s'il faut utiliser une activation tanh pour la prédiction des actions

vocab_size (`int`, *facultatif*, valeur par défaut `1`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

n_positions (`int`, *facultatif*, valeur par défaut `1024`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

n_layer (`int`, *facultatif*, valeur par défaut `3`) : Nombre de couches cachées dans le décodeur Transformer.

n_head (`int`, *facultatif*, valeur par défaut `1`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

n_inner (`int`, *facultatif*) : Dimension des représentations MLP.

activation_function (`str`, *facultatif*, par défaut `relu`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

resid_pdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.

embd_pdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le taux de dropout pour les embeddings.

attn_pdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le taux de dropout appliqué aux probabilités d'attention.

layer_norm_epsilon (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

scale_attn_weights (`bool`, *facultatif*, par défaut `True`) : Échelle des poids d'attention en les divisant par sqrt(hidden_size)..

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement.

bos_token_id (`int`, *facultatif*, valeur par défaut `50256`) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `50256`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

scale_attn_by_inverse_layer_idx (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut également mettre à l'échelle les poids d'attention par `1 / layer_idx + 1`.

reorder_and_upcast_attn (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut mettre à l'échelle les clés (K) avant de calculer l'attention (produit scalaire) et de convertir le produit scalaire de l'attention/softmax en float() lors de l'entraînement avec précision mixte.

add_cross_attention (`bool`, *facultatif*, par défaut `False`) : Indique si des couches d'attention croisée doivent être ajoutées au modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un DecisionTransformerModel. Elle est utilisée pour instancier un modèle Decision Transformer en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [](https://huggingface.co/)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import DecisionTransformerConfig, DecisionTransformerModel

>>> # Initializing a DecisionTransformer configuration
>>> configuration = DecisionTransformerConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = DecisionTransformerModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## DecisionTransformerGPT2Model[[transformers.DecisionTransformerGPT2Model]]

#### transformers.DecisionTransformerGPT2Model[[transformers.DecisionTransformerGPT2Model]]

```python
transformers.DecisionTransformerGPT2Model(config: DecisionTransformerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/decision_transformer/modeling_decision_transformer.py#L346)

#### forward[[transformers.DecisionTransformerGPT2Model.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/decision_transformer/modeling_decision_transformer.py#L372)

## DecisionTransformerModel[[transformers.DecisionTransformerModel]]

#### transformers.DecisionTransformerModel[[transformers.DecisionTransformerModel]]

```python
transformers.DecisionTransformerModel(config: DecisionTransformerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/decision_transformer/modeling_decision_transformer.py#L505)

**Paramètres :**

config ([DecisionTransformerConfig](/docs/transformers/v5.23.0/fr/model_doc/decision_transformer#transformers.DecisionTransformerConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Decision Transformer

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.DecisionTransformerModel.forward]]

```python
forward(states: typing.Optional[torch.Tensor] = None, actions: typing.Optional[torch.Tensor] = None, rewards: typing.Optional[torch.Tensor] = None, returns_to_go: typing.Optional[torch.Tensor] = None, timesteps: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/decision_transformer/modeling_decision_transformer.py#L538)

**Paramètres :**

states (`torch.Tensor` de forme `(batch_size, episode_length, state_dim)`) : Les états pour chaque étape de la trajectoire

actions (`torch.Tensor` de forme `(batch_size, episode_length, act_dim)`) : Les actions prises par la politique « experte » pour l'état actuel, masquées pour la prédiction auto-régressive

rewards (`torch.Tensor` de forme `(batch_size, episode_length, 1)`) : Les récompenses pour chaque état, action

returns_to_go (`torch.Tensor` de forme `(batch_size, episode_length, 1)`) : Les retours pour chaque état de la trajectoire

timesteps (`torch.LongTensor` de forme `(batch_size, episode_length)`) : L'instant temporel pour chaque étape de la trajectoire

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** `DecisionTransformerOutput` ou `tuple(torch.Tensor)`

Un `DecisionTransformerOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([DecisionTransformerConfig](/docs/transformers/v5.23.0/fr/model_doc/decision_transformer#transformers.DecisionTransformerConfig)) et les entrées.

La méthode forward du [DecisionTransformerModel](/docs/transformers/v5.23.0/fr/model_doc/decision_transformer#transformers.DecisionTransformerModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **state_preds** (`torch.Tensor` de forme `(batch_size, sequence_length, state_dim)`) -- Prédictions de l'état de l'environnement
- **action_preds** (`torch.Tensor` de forme `(batch_size, sequence_length, action_dim)`) -- Prédictions d'action du modèle
- **return_preds** (`torch.Tensor` de forme `(batch_size, sequence_length, 1)`) -- Rendements prédits pour chaque état
- **hidden_states** (`torch.Tensor`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`torch.Tensor`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.

Exemples :

```python
>>> from transformers import DecisionTransformerModel
>>> import torch

>>> model = DecisionTransformerModel.from_pretrained("edbeeching/decision-transformer-gym-hopper-medium")
>>> # evaluation
>>> model = model.to(device)
>>> model.eval()

>>> env = gym.make("Hopper-v3")
>>> state_dim = env.observation_space.shape[0]
>>> act_dim = env.action_space.shape[0]

>>> state = env.reset()
>>> states = torch.from_numpy(state).reshape(1, 1, state_dim).to(device=device, dtype=torch.float32)
>>> actions = torch.zeros((1, 1, act_dim), device=device, dtype=torch.float32)
>>> rewards = torch.zeros(1, 1, device=device, dtype=torch.float32)
>>> target_return = torch.tensor(TARGET_RETURN, dtype=torch.float32).reshape(1, 1)
>>> timesteps = torch.tensor(0, device=device, dtype=torch.long).reshape(1, 1)
>>> attention_mask = torch.zeros(1, 1, device=device, dtype=torch.float32)

>>> # forward pass
>>> with torch.no_grad():
...     state_preds, action_preds, return_preds = model(
...         states=states,
...         actions=actions,
...         rewards=rewards,
...         returns_to_go=target_return,
...         timesteps=timesteps,
...         attention_mask=attention_mask,
...         return_dict=False,
...     )
```

