Hugging Face's logo

Transformers documentation

Decision Transformer

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2021-06-02 et ajouté à Hugging Face Transformers le 2022-03-23.

Decision Transformer

Aperçu

Le modèle Decision Transformer a été proposé dans Decision Transformer: Reinforcement Learning via Sequence Modeling
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 du langage, telles que GPT-x et BERT. En particulier, nous présentons Decision Transformer, une architecture qui formule 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 hors-ligne model-free de pointe 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. Le code d'origine peut être trouvé ici.

DecisionTransformerConfig

classe transformers.DecisionTransformerConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonestate_dim: int = 17act_dim: int = 4hidden_size: int = 128max_ep_len: int = 4096action_tanh: bool = Truevocab_size: int = 1n_positions: int = 1024n_layer: int = 3n_head: int = 1n_inner: int | None = Noneactivation_function: str = 'relu'resid_pdrop: float | int = 0.1embd_pdrop: float | int = 0.1attn_pdrop: float | int = 0.1layer_norm_epsilon: float = 1e-05initializer_range: float = 0.02scale_attn_weights: bool = Trueuse_cache: bool = Truebos_token_id: int | None = 50256eos_token_id: int | list[int] | None = 50256scale_attn_by_inverse_layer_idx: bool = Falsereorder_and_upcast_attn: bool = Falseadd_cross_attention: bool = False )

Paramètres

  • state_dim (int, facultatif, valeur par défaut 17) — Taille de l'état pour l'environnement RL
  • act_dim (int, facultatif, par défaut 4) — La taille de l'espace des 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, valeur par défaut True) — Indique s'il faut utiliser une activation tanh sur la prédiction de l'action
  • vocab_size (int, facultatif, 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, par défaut 1024) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • n_layer (int, facultatif, par défaut 3) — Nombre de couches cachées dans le décodeur Transformer.
  • n_head (int, facultatif, 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 du MLP.
  • activation_function (str, facultatif, par défaut relu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • resid_pdrop (Union[float, int], facultatif, valeur par défaut 0.1) — 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, par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • scale_attn_weights (bool, facultatif, par défaut True) — Échelle des poids d'attention en 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). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • bos_token_id (int, facultatif, par défaut 50256) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif, par défaut 50256) — Identifiant du 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, par défaut False) — Indique s'il faut mettre à l'échelle les clés (K) avant de calculer l'attention (produit scalaire) et convertir le produit scalaire/softmax de l'attention en float() lors de l'entraînement avec précision mixte.
  • add_cross_attention (bool, facultatif, valeur 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, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> 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

classe transformers.DecisionTransformerGPT2Model

< >

( config: DecisionTransformerConfig )

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

DecisionTransformerModel

classe transformers.DecisionTransformerModel

< >

( config: DecisionTransformerConfig )

Paramètres

  • config (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() pour charger les poids du modèle.

Le modèle Decision Transformer

Ce modèle hérite de 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( states: typing.Optional[torch.Tensor] = Noneactions: typing.Optional[torch.Tensor] = Nonerewards: typing.Optional[torch.Tensor] = Nonereturns_to_go: typing.Optional[torch.Tensor] = Nonetimesteps: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → DecisionTransformerOutput or tuple(torch.Tensor)

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'indice de temps 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous 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. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un 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 en fonction de la configuration (DecisionTransformerConfig) et des entrées.

La méthode forward du 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’actions 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).

    Poids des attentions après le softmax d'attention, utilisés 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 :

>>> 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,
...     )
Update on GitHub

←X-CLIP Autoformer→