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

Este modelo foi publicado no HF papers em 2021-06-02 e contribuído para o Hugging Face Transformers em 2022-03-23.

Decision Transformer

Visão geral

O modelo Decision Transformer foi proposto em Decision Transformer: Reinforcement Learning via Sequence Modeling
por Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, Igor Mordatch.

O resumo do artigo é o seguinte:

Apresentamos um framework que abstrai o Aprendizado por Reforço (RL) como um problema de modelagem de sequências. Isso nos permite aproveitar a simplicidade e a escalabilidade da arquitetura Transformer, bem como os avanços associados na modelagem de linguagem, como GPT-x e BERT. Em particular, apresentamos o Decision Transformer, uma arquitetura que formula o problema de RL como modelagem de sequência condicional. Diferentemente de abordagens anteriores de RL que ajustam funções de valor ou calculam gradientes de política, o Decision Transformer simplesmente produz as ações ótimas aproveitando um Transformer com máscara causal. Ao condicionar um modelo autoregressivo no retorno desejado (recompensa), nos estados e ações passados, nosso modelo Decision Transformer pode gerar ações futuras que alcancam o retorno desejado. Apesar da sua simplicidade, o Decision Transformer iguala ou supera o desempenho de baselines offline de RL model-free state-of-the-art em tarefas de Atari, OpenAI Gym e Key-to-Door.

Esta versão do modelo é para tarefas em que o estado é um vetor.

Este modelo foi contribuído por edbeeching. O código original pode ser encontrado aqui.

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 )

Parâmetros

  • state_dim (int, opcional, padrão 17) — O tamanho do estado para o ambiente de RL
  • act_dim (int, opcional, padrão 4) — O tamanho do espaço de ações de saída
  • hidden_size (int, opcional, padrão 128) — Dimensão das representações ocultas.
  • max_ep_len (int, opcional, padrão 4096) — O comprimento máximo de um episódio no ambiente
  • action_tanh (bool, opcional, padrão True) — Se deve usar uma ativação tanh na previsão da ação
  • vocab_size (int, opcional, padrão 1) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • n_positions (int, opcional, padrão 1024) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • n_layer (int, opcional, padrão 3) — Número de camadas ocultas no decodificador do Transformer.
  • n_head (int, opcional, padrão 1) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • n_inner (int, opcional) — Dimensão das representações do MLP.
  • activation_function (str, opcional, padrão relu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • resid_pdrop (Union[float, int], opcional, padrão 0.1) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.
  • embd_pdrop (Union[float, int], opcional, padrão 0.1) — A taxa de dropout para os embeddings.
  • attn_pdrop (Union[float, int], opcional, padrão 0.1) — A taxa de dropout para as probabilidades de atenção.
  • layer_norm_epsilon (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização de camada.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • scale_attn_weights (bool, opcional, padrão True) — Escala os pesos de atenção dividindo por sqrt(hidden_size).
  • use_cache (bool, opcional, padrão True) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas se config.is_decoder=True ou quando o modelo for um modelo generativo somente decodificador.
  • bos_token_id (int, opcional, padrão 50256) — ID do token usado para o início do fluxo no vocabulário.
  • eos_token_id (Union[int, list[int]], opcional, padrão 50256) — ID do token usado para o fim do fluxo no vocabulário.
  • scale_attn_by_inverse_layer_idx (bool, opcional, padrão False) — Se as pesos de atenção devem ser escalados adicionalmente por 1 / layer_idx + 1.
  • reorder_and_upcast_attn (bool, opcional, padrão False) — Se deve escalar as chaves (K) antes de calcular a atenção (produto escalar) e fazer o upcast do produto escalar/softmax da atenção para float() durante o treinamento com precisão mista.
  • add_cross_attention (bool, opcional, padrão False) — Se camadas de atenção cruzada devem ser adicionadas ao modelo.

Esta é a classe de configuração para armazenar a configuração de um DecisionTransformerModel. Ela é usada para instanciar um modelo Decision Transformer de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

Parâmetros

  • config (DecisionTransformerConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O Modelo Decision Transformer

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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)

Parâmetros

  • states (torch.Tensor de forma (batch_size, episode_length, state_dim)) — Os estados para cada passo na trajetória
  • actions (torch.Tensor de forma (batch_size, episode_length, act_dim)) — As ações tomadas pela política “especialista” para o estado atual, que são mascaradas para a previsão auto regressiva
  • rewards (torch.Tensor de forma (batch_size, episode_length, 1)) — As recompensas para cada estado, ação
  • returns_to_go (torch.Tensor de forma (batch_size, episode_length, 1)) — Os retornos para cada estado na trajetória
  • timesteps (torch.LongTensor de forma (batch_size, episode_length)) — O timestep para cada passo na trajetória
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
  • output_attentions (bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions nos tensores retornados para mais detalhes.
  • return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

DecisionTransformerOutput ou tuple(torch.Tensor)

Um DecisionTransformerOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (DecisionTransformerConfig) e das entradas.

O método forward do DecisionTransformerModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • state_preds (torch.Tensor de forma (batch_size, sequence_length, state_dim)) — Previsões do estado do ambiente

  • action_preds (torch.Tensor de forma (batch_size, sequence_length, action_dim)) — Previsões de ação do modelo

  • return_preds (torch.Tensor de forma (batch_size, sequence_length, 1)) — Retornos previstos para cada estado

  • hidden_states (torch.Tensor, opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (torch.Tensor, opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do modelo.

Exemplos:

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