该模型于 2021-06-02 在 HF papers 上发布，并于 2022-03-23 贡献给 Hugging Face Transformers。

Decision Transformer

概述

Decision Transformer 模型由 Lili Chen、Kevin Lu、Aravind Rajeswaran、Kimin Lee、Aditya Grover、Michael Laskin、Pieter Abbeel、Aravind Srinivas 和 Igor Mordatch 在 Decision Transformer: Reinforcement Learning via Sequence Modeling
中提出。

该论文的摘要如下：

我们提出了一个将强化学习（RL）抽象为序列建模问题的框架。这使得我们能够利用 Transformer 架构的简洁性和可扩展性，以及 GPT-x 和 BERT 等语言建模方面的相关进展。具体而言，我们提出了 Decision Transformer，这是一种将强化学习问题转化为条件序列建模的架构。与拟合价值函数或计算策略梯度的传统强化学习方法不同，Decision Transformer 通过利用因果掩码 Transformer 直接输出最优动作。通过以期望回报（奖励）、历史状态和动作为条件，我们的 Decision Transformer 模型能够生成实现期望回报的未来动作。尽管其结构简洁，Decision Transformer 在 Atari、OpenAI Gym 和 Key-to-Door 任务上的表现与最先进的无模型离线强化学习基线相当或更优。

此版本的模型适用于状态为向量的任务。

该模型由 edbeeching 贡献。原始代码可在此处找到。

DecisionTransformerConfig

class transformers.DecisionTransformerConfig

< source >

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

参数

state_dim (int，可选，默认为 17) — RL 环境的状态大小
act_dim (int，可选，默认为 4) — 输出动作空间的大小
hidden_size (int，可选，默认为 128) — 隐藏表示的维度。
max_ep_len (int，可选，默认值为 4096) — 环境中单个 episode 的最大长度
action_tanh (bool，可选，默认为 True) — 是否对动作预测使用 tanh 激活函数
vocab_size (int，可选，默认为 1) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 数量。
n_positions (int，可选，默认为 1024) — 该模型可能使用的最大序列长度。
n_layer (int，可选，默认为 3) — Transformer 解码器中的隐藏层数。
n_head (int，可选，默认为 1) — Transformer 解码器中每个注意力层的注意力头数量。
n_inner (int，可选) — MLP 表示的维度。
activation_function (str，可选，默认为 relu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu" 等。
resid_pdrop (Union[float, int]，可选，默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。
embd_pdrop (Union[float, int]，可选，默认为 0.1) — 嵌入层的 dropout 比率。
attn_pdrop（Union[float, int]，可选，默认值为 0.1） — 注意力概率的 dropout 比率。
layer_norm_epsilon (float，可选，默认为 1e-05) — 层归一化层所使用的 epsilon 值。
initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
scale_attn_weights (bool，可选，默认为 True) — 通过将注意力权重除以 sqrt(hidden_size) 进行缩放。
use_cache (bool，可选，默认为 True) — 模型是否应返回最后一次键/值注意力（并非所有模型都使用）。仅当 config.is_decoder=True 或模型为仅解码器生成式模型时相关。
bos_token_id (int，可选，默认为 50256) — 词汇表中用于表示流起始的 Token id。
eos_token_id (Union[int, list[int]]，可选，默认为 50256) — 词汇表中用于表示流结束（end-of-stream）的 token id。
scale_attn_by_inverse_layer_idx (bool，可选，默认为 False) — 是否额外将注意力权重乘以 1 / layer_idx + 1。
reorder_and_upcast_attn (bool，可选，默认为 False) — 是否在进行混合精度训练时，在计算注意力（点积）之前对键（K）进行缩放，并将注意力点积/softmax 上转为 float()。
add_cross_attention (bool，可选，默认为 False) — 是否应在模型中添加交叉注意力层。

这是用于存储 DecisionTransformerModel 配置的类。它根据指定的参数实例化 Decision Transformer 模型，并定义模型架构。使用默认值实例化配置将生成与类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

示例：

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

class transformers.DecisionTransformerGPT2Model

< source >

( config: DecisionTransformerConfig )

forward

< source >

( 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

class transformers.DecisionTransformerModel

< source >

( config: DecisionTransformerConfig )

参数

config (DecisionTransformerConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

Decision Transformer 模型

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< source >

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

参数

states（形状为 (batch_size, episode_length, state_dim) 的 torch.Tensor）— 轨迹中每一步的状态
actions (torch.Tensor，形状为 (batch_size, episode_length, act_dim)) — “专家”策略在当前状态下采取的动作，这些动作在自回归预测中会被屏蔽
rewards（形状为 (batch_size, episode_length, 1) 的 torch.Tensor）— 每个状态和动作对应的奖励
returns_to_go (torch.Tensor，形状为 (batch_size, episode_length, 1)) — 轨迹中每个状态的回报
timesteps（形状为 (batch_size, episode_length) 的 torch.LongTensor）— 轨迹中每个时间步的时间步
attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
什么是注意力掩码？
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

DecisionTransformerOutput 或 tuple(torch.Tensor)

DecisionTransformerOutput 或 torch.Tensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（DecisionTransformerConfig）和输入。

DecisionTransformerModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

state_preds（形状为 (batch_size, sequence_length, state_dim) 的 torch.Tensor）— 环境状态预测
action_preds（形状为 (batch_size, sequence_length, action_dim) 的 torch.Tensor）— 模型的动作预测
return_preds（形状为 (batch_size, sequence_length, 1) 的 torch.Tensor）— 每个状态的预测回报
hidden_states (torch.Tensor，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.Tensor 的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions（torch.Tensor，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选）— 模型最后一层输出的隐藏状态序列。

示例：

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