# Decision Transformer

## Ikhtisar

Model Decision Transformer diusulkan dalam [Decision Transformer: Reinforcement Learning via Sequence Modeling](https://huggingface.co/papers/2106.01345) oleh Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, Igor Mordatch.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Kami memperkenalkan sebuah kerangka kerja yang mengabstraksi Reinforcement Learning (RL) sebagai masalah pemodelan sekuens. Hal ini memungkinkan kami untuk memanfaatkan kesederhanaan dan skalabilitas arsitektur Transformer, serta kemajuan terkait dalam pemodelan bahasa seperti GPT-x dan BERT. Secara khusus, kami menyajikan Decision Transformer, sebuah arsitektur yang memformulasikan masalah RL sebagai pemodelan sekuens kondisional. Berbeda dengan pendekatan RL sebelumnya yang menyesuaikan fungsi nilai atau menghitung gradien kebijakan, Decision Transformer secara sederhana mengoutputkan aksi-aksi optimal dengan memanfaatkan Transformer yang dimask secara kausal. Dengan mengondisikan model autoregresif pada return (reward) yang diinginkan, keadaan masa lalu, dan aksi, model Decision Transformer kami dapat menghasilkan aksi-aksi masa depan yang mencapai return yang diinginkan. Meskipun sederhana, Decision Transformer menyamai atau melampaui kinerja baseline offline RL model-free state-of-the-art pada tugas-tugas Atari, OpenAI Gym, dan Key-to-Door.*

Versi model ini ditujukan untuk tugas di mana state berupa vektor.

Model ini disumbangkan oleh [edbeeching](https://huggingface.co/edbeeching). Kode aslinya dapat ditemukan [di sini](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)
```

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

**Parameter:**

state_dim (`int`, *opsional*, defaultnya 17) : Ukuran state untuk lingkungan RL

act_dim (`int`, *opsional*, defaultnya 4) : Ukuran ruang aksi output

hidden_size (`int`, *opsional*, defaultnya `128`) : Dimensi dari representasi tersembunyi.

max_ep_len (`int`, *opsional*, defaultnya 4096) : Panjang maksimum episode di lingkungan

action_tanh (`bool`, *opsional*, defaultnya True) : Apakah akan menggunakan aktivasi tanh pada prediksi aksi

vocab_size (`int`, *opsional*, defaultnya `1`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

n_positions (`int`, *opsional*, defaultnya `1024`) : Panjang urutan maksimum yang mungkin digunakan oleh model ini.

n_layer (`int`, *opsional*, defaultnya `3`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

n_head (`int`, *opsional*, defaultnya `1`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

n_inner (`int`, *opsional*) : Dimensi dari representasi MLP.

activation_function (`str`, *opsional*, defaultnya `relu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

resid_pdrop (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.

embd_pdrop (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio dropout untuk embeddings.

attn_pdrop (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio dropout untuk probabilitas perhatian.

layer_norm_epsilon (`float`, *opsional*, defaultnya `1e-05`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

scale_attn_weights (`bool`, *opsional*, defaultnya `True`) : Skala bobot perhatian dengan membagi oleh sqrt(hidden_size).

use_cache (`bool`, *opsional*, defaultnya `True`) : Apakah model harus mengembalikan perhatian kunci/nilai terakhir (tidak digunakan oleh semua model). Hanya relevan jika `config.is_decoder=True` atau ketika model adalah model generatif yang hanya decoder.

bos_token_id (`int`, *opsional*, defaultnya `50256`) : Token id yang digunakan untuk awal-stream dalam kosakata.

eos_token_id (`Union[int, list[int]]`, *opsional*, defaultnya `50256`) : Token id yang digunakan untuk end-of-stream dalam kosakata.

scale_attn_by_inverse_layer_idx (`bool`, *opsional*, defaultnya `False`) : Apakah bobot perhatian akan diskalakan tambahan dengan `1 / layer_idx + 1`.

reorder_and_upcast_attn (`bool`, *opsional*, defaultnya `False`) : Apakah akan menskalakan kunci (K) sebelum menghitung perhatian (dot-product) dan menaikkan tipe (upcast) dot-product/softmax perhatian ke float() saat melatih dengan presisi campuran.

add_cross_attention (`bool`, *opsional*, defaultnya `False`) : Apakah lapisan cross-attention harus ditambahkan ke model.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari DecisionTransformerModel. Kelas ini digunakan untuk membuat instans model Decision Transformer sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [](https://huggingface.co/)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/main/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'>)
```

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

## DecisionTransformerModel[[transformers.DecisionTransformerModel]]

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

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

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

**Parameter:**

config ([DecisionTransformerConfig](/docs/transformers/main/id/model_doc/decision_transformer#transformers.DecisionTransformerConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Decision Transformer

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

**Parameter:**

states (`torch.Tensor` dengan bentuk `(batch_size, episode_length, state_dim)`) : State untuk setiap langkah dalam trajektori

actions (`torch.Tensor` dengan bentuk `(batch_size, episode_length, act_dim)`) : Aksi yang diambil oleh kebijakan "expert" untuk keadaan saat ini, aksi ini dimasker untuk prediksi auto regressive

rewards (`torch.Tensor` dengan bentuk `(batch_size, episode_length, 1)`) : Hadiah untuk setiap state dan action

returns_to_go (`torch.Tensor` dengan bentuk `(batch_size, episode_length, 1)`) : Return untuk setiap state dalam trajektori

timesteps (`torch.LongTensor` dengan bentuk `(batch_size, episode_length)`) : timestep untuk setiap langkah dalam trajektori

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** `DecisionTransformerOutput` atau `tuple(torch.Tensor)`

Sebuah `DecisionTransformerOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DecisionTransformerConfig](/docs/transformers/main/id/model_doc/decision_transformer#transformers.DecisionTransformerConfig)) dan input.

Metode forward dari [DecisionTransformerModel](/docs/transformers/main/id/model_doc/decision_transformer#transformers.DecisionTransformerModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **state_preds** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, state_dim)`) -- Prediksi state lingkungan
- **action_preds** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, action_dim)`) -- Prediksi aksi model
- **return_preds** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, 1)`) -- Return yang diprediksi untuk setiap state
- **hidden_states** (`torch.Tensor`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`torch.Tensor`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran dari lapisan terakhir model.

Contoh:

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