Add Simulusion 1.1.0 demo checkpoint

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+iris_dream.gif filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,86 @@
+---
+library_name: simulusion
+license: mit
+pipeline_tag: reinforcement-learning
+tags:
+- simulusion
+- pytorch
+- iris
+- model-based-rl
+- atari
+- transformer
+- world-model
+---
+
+# IRIS on Atari Boxing
+
+![IRIS imagining Boxing token by token](iris_dream.gif)
+
+A demo checkpoint from [Simulusion](https://github.com/ParamThakkar123/simulusion), an open-source PyTorch library that puts world models behind one API. It implements the paper **[Transformers are Sample-Efficient World Models (Micheli et al., ICLR 2023)](https://arxiv.org/abs/2209.00588)**.
+
+IRIS compresses every frame into 16 discrete tokens with a VQ autoencoder, models the game as a sequence of tokens and actions with a Transformer, and trains its policy only on the Transformer's imagination.
+
+## Results
+
+Trained for 300 epochs (60,000 real environment steps) on a 4 GB RTX 3050 laptop GPU. The world model keeps the ring, both boxers and the scoreboard, and the policy has learned to close in and trade punches. In a full round in the real emulator it led 29-21 with 24 seconds left and lost **31-32**: level with the game's built-in opponent, not yet better. The paper reaches about +70 with several times more policy training per epoch.
+
+This is a short demo run sized for a laptop GPU, meant to show what the model does. It is **not** a reproduction of the paper's results. More clips and learning curves are in the [gallery](https://paramthakkar123.github.io/simulusion/gallery.html).
+
+## Usage
+
+```bash
+pip install simulusion huggingface_hub
+```
+
+```python
+from huggingface_hub import snapshot_download
+from simulusion.world_model import load_world_model
+
+path = snapshot_download("simillusion/iris-atari-boxing")
+wm = load_world_model(path, "iris")  # encode / step / rollout / decode
+```
+
+The same interface works for every world model in Simulusion. To get the full agent:
+
+```python
+from simulusion.models.iris_agent import IRISAgent
+
+# The first load also downloads torchvision's VGG16 (528 MB) for the perceptual loss
+agent = IRISAgent.from_pretrained(path)
+```
+
+Checkpoints are plain state dicts and load with `torch.load(..., weights_only=True)`. They include optimizer state, so you can continue training from them.
+
+## Training
+
+Reproduce this checkpoint from a clone of the repository:
+
+```bash
+python demos/iris_demo.py train --game ALE/Boxing-v5 --run demos/runs/iris_boxing --until-epoch 300 \
+    --autoencoder-steps 200 --transformer-steps 200 --actor-critic-steps 50 --actor-critic-batch 64
+```
+
+## Citation
+
+If you use this model, please cite the original paper:
+
+```bibtex
+@inproceedings{micheli2023iris,
+  title     = {Transformers are Sample-Efficient World Models},
+  author    = {Micheli, Vincent and Alonso, Eloi and Fleuret, Fran{\c{c}}ois},
+  booktitle = {International Conference on Learning Representations},
+  year      = {2023},
+  url       = {https://arxiv.org/abs/2209.00588},
+}
+```
+
+and Simulusion:
+
+```bibtex
+@software{simulusion,
+  title  = {Simulusion: a PyTorch library for world models},
+  author = {Thakkar, Param},
+  year   = {2026},
+  url    = {https://github.com/ParamThakkar123/simulusion},
+}
+```

config.yaml

@@ -0,0 +1,67 @@
+action_repeat: 4
+actor_critic_batch_size: 64
+actor_critic_steps_per_epoch: 50
+actor_hidden_size: 512
+actor_layers: 1
+actor_learning_rate: 0.0001
+adam_beta1: 0.9
+adam_beta2: 0.999
+atari_100k: true
+autoencoder_batch_size: 64
+burn_in_length: 20
+checkpoint_interval: 50
+collect_epsilon: 0.01
+collect_temperature: 1.0
+collection_epochs: 500
+commitment_weight: 1.0
+decoder_depth: 64
+discount: 0.995
+early_stopping: false
+encoder_channels: 64
+encoder_layers: 4
+encoder_residual_blocks: 2
+entropy_coef: 0.001
+env: ALE/Pong-v5
+env_backend: gym
+env_steps_per_epoch: 200
+eval_episodes: 100
+eval_temperature: 0.5
+frame_channels: 3
+frame_height: 64
+frame_width: 64
+grad_clip_norm: 10.0
+gradient_checkpointing: true
+imagination_horizon: 20
+log_interval: 1000
+max_env_steps: 100000
+max_episode_steps: 27000
+min_delta: 0.0001
+model_learning_rate: 0.0001
+patience: 10
+perceptual_blocks: 5
+perceptual_linear_weights: ''
+perceptual_weight: 1.0
+quantizer: gradient
+reconstruction_weight: 1.0
+repeat_action_probability: 0.0
+reward_loss: cross_entropy
+reward_transform: sign
+start_actor_critic_after: 50
+start_autoencoder_after: 5
+start_transformer_after: 25
+td_lambda: 0.95
+token_embedding_dim: 512
+tokens_per_frame: 16
+total_epochs: 600
+training_steps_per_epoch: 200
+transformer_batch_size: 16
+transformer_dropout: 0.1
+transformer_embed_dim: 256
+transformer_heads: 4
+transformer_layers: 10
+transformer_steps_per_epoch: 200
+transformer_timesteps: 20
+use_amp: true
+value_learning_rate: 0.0001
+vocab_size: 512
+weight_decay: 0.01

model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46e997fd903e66b3c1e789c8cbe80166ed4412d81ab23a99507b25686035c384
+size 174388401