# Decision Transformer

## Resumen

El modelo Decision Transformer fue propuesto en [Decision Transformer: Reinforcement Learning via Sequence Modeling](https://huggingface.co/papers/2106.01345) por Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, Igor Mordatch.

El resumen del artículo es el siguiente:

*Presentamos un marco que abstrae el Aprendizaje por Refuerzo (RL) como un problema de modelado de secuencias. Esto nos permite aprovechar la simplicidad y escalabilidad de la arquitectura Transformer, así como los avances asociados en el modelado de lenguaje, como GPT-x y BERT. En particular, presentamos Decision Transformer, una arquitectura que plantea el problema de RL como modelado de secuencias condicional. A diferencia de los enfoques previos de RL que ajustan funciones de valor o calculan gradientes de política, Decision Transformer simplemente emite las acciones óptimas aprovechando un Transformer con enmascaramiento causal. Al condicionar un modelo autoregresivo en el retorno (recompensa) deseado, los estados y acciones pasados, nuestro modelo Decision Transformer puede generar acciones futuras que logren el retorno deseado. A pesar de su simplicidad, Decision Transformer iguala o supera el rendimiento de las líneas base de RL offline model-free de última generación en tareas de Atari, OpenAI Gym y Key-to-Door.*

Esta versión del modelo es para tareas donde el estado es un vector.

Este modelo fue aportado por [edbeeching](https://huggingface.co/edbeeching). El código original se puede encontrar [aquí](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)
```

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

**Parámetros:**

state_dim (`int`, *opcional*, valor predeterminado 17) : El tamaño del estado para el entorno de RL

act_dim (`int`, *opcional*, valor predeterminado 4) : El tamaño del espacio de acciones de salida

hidden_size (`int`, *opcional*, valor predeterminado `128`) : Dimensión de las representaciones ocultas.

max_ep_len (`int`, *opcional*, valor predeterminado 4096) : La longitud máxima de un episodio en el entorno

action_tanh (`bool`, *opcional*, predeterminado a True) : Si se debe usar una activación tanh en la predicción de la acción

vocab_size (`int`, *opcional*, valor predeterminado `1`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

n_positions (`int`, *opcional*, valor predeterminado `1024`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

n_layer (`int`, *opcional*, valor predeterminado `3`) : Número de capas ocultas en el decodificador del Transformer.

n_head (`int`, *opcional*, valor predeterminado `1`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

n_inner (`int`, *opcional*) : Dimensión de las representaciones del MLP.

activation_function (`str`, *opcional*, valor predeterminado `relu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

resid_pdrop (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de dropout para todas las capas totalmente conectadas en los embeddings, el codificador y el pooler.

embd_pdrop (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para los embeddings.

attn_pdrop (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para las probabilidades de atención.

layer_norm_epsilon (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización de capas.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

scale_attn_weights (`bool`, *opcional*, valor predeterminado `True`) : Escala los pesos de atención dividiendo por sqrt(hidden_size).

use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador.

bos_token_id (`int`, *opcional*, valor predeterminado `50256`) : Id de token utilizado para el inicio de la secuencia en el vocabulario.

eos_token_id (`Union[int, list[int]]`, *opcional*, valor predeterminado `50256`) : Id. de token utilizado para el fin de secuencia en el vocabulario.

scale_attn_by_inverse_layer_idx (`bool`, *opcional*, valor predeterminado `False`) : Si se deben escalar adicionalmente los pesos de atención por `1 / layer_idx + 1`.

reorder_and_upcast_attn (`bool`, *opcional*, valor predeterminado `False`) : Si se deben escalar las claves (K) antes de calcular la atención (producto punto) y si se debe convertir el producto punto/softmax de la atención a float() durante el entrenamiento con precisión mixta.

add_cross_attention (`bool`, *opcional*, valor predeterminado `False`) : Si se deben añadir capas de atención cruzada al modelo.

Esta es la clase de configuración para almacenar la configuración de un DecisionTransformerModel. Se utiliza para instanciar un modelo Decision Transformer según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [](https://huggingface.co/)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

[Fuente](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'>)
```

[Fuente](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)
```

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

**Parámetros:**

config ([DecisionTransformerConfig](/docs/transformers/v5.23.0/es/model_doc/decision_transformer#transformers.DecisionTransformerConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Decision Transformer

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

**Parámetros:**

states (`torch.Tensor` de forma `(batch_size, episode_length, state_dim)`) : Los estados para cada paso en la trayectoria

actions (`torch.Tensor` de forma `(batch_size, episode_length, act_dim)`) : Las acciones tomadas por la política "experta" para el estado actual, estas se enmascaran para la predicción auto regresiva

rewards (`torch.Tensor` de forma `(batch_size, episode_length, 1)`) : Las recompensas para cada estado y acción

returns_to_go (`torch.Tensor` de forma `(batch_size, episode_length, 1)`) : Las recompensas acumuladas para cada estado en la trayectoria

timesteps (`torch.LongTensor` de forma `(batch_size, episode_length)`) : El paso de tiempo para cada paso en la trayectoria

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** `DecisionTransformerOutput` o `tuple(torch.Tensor)`

Un `DecisionTransformerOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([DecisionTransformerConfig](/docs/transformers/v5.23.0/es/model_doc/decision_transformer#transformers.DecisionTransformerConfig)) y las entradas.

El método forward de [DecisionTransformerModel](/docs/transformers/v5.23.0/es/model_doc/decision_transformer#transformers.DecisionTransformerModel) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **state_preds** (`torch.Tensor` de forma `(batch_size, sequence_length, state_dim)`) -- Predicciones del estado del entorno
- **action_preds** (`torch.Tensor` de forma `(batch_size, sequence_length, action_dim)`) -- Predicciones de acción del modelo
- **return_preds** (`torch.Tensor` de forma `(batch_size, sequence_length, 1)`) -- Retornos predichos para cada estado
- **hidden_states** (`torch.Tensor`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`torch.Tensor`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del modelo.

Ejemplos:

```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,
...     )
```

