Upload 385 files

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+gpudrive-main/papers/LLM评估场景.pdf filter=lfs diff=lfs merge=lfs -text
+gpudrive-main/server_resource/event_traces.jsonl filter=lfs diff=lfs merge=lfs -text

gpudrive-main/.dockerignore

@@ -0,0 +1,6 @@
+Dockerfile
+.*
+!.git
+!.gitignore
+!.gitmodules
+!.python-version

gpudrive-main/.env.template

@@ -0,0 +1,13 @@
+# .env template
+
+# Path for logs
+LOG_FOLDER=
+
+# Your HPC account code
+NYU_HPC_ACCOUNT=
+
+# NYU ID
+USERNAME=
+
+SINGULARITY_IMAGE=
+OVERLAY_FILE=

gpudrive-main/.github/workflows/ci.yml

@@ -0,0 +1,42 @@
+name: Continuous Integration
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  build-and-smoketest:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Build Docker image
+        run: docker build --tag gpudrive:latest .
+
+      - name: Run smoke test inside Docker container (using a here document)
+        run: |
+          docker run --rm gpudrive:latest /bin/bash -c "$(cat << 'EOF'
+          #!/bin/bash
+          set -e
+          set -x
+          export DEBIAN_FRONTEND=noninteractive
+          echo 'Dummy cuda'
+          ln -s /usr/local/cuda/lib64/stubs/libcuda.so /usr/local/cuda/lib64/stubs/libcuda.so.1
+          export LD_LIBRARY_PATH=/usr/local/cuda/lib64/stubs/:$LD_LIBRARY_PATH
+          echo 'Modifications to run without extra data'
+          sed -i 's|train_path: \"data/processed/training\"|train_path: \"data/processed/examples\"|g' examples/experimental/config/visualization_config.yaml
+          sed -i '/# Load policy/{N;N;N;N;N;N;s|# Load policy\n    policy = load_policy(\n        path_to_cpt=config.cpt_path,\n        model_name=config.cpt_name,\n        device=config.device,\n        env=env,\n    )|from gpudrive.networks.late_fusion import NeuralNet\n    policy = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S10_000_02_27\")|}' examples/experimental/viz_rollouts.py
+          echo 'Modifications to run without GPU'
+          sed -i 's/device=\"cuda\"/device=\"cpu\"/g' gpudrive/datatypes/observation.py
+          export PYTHONFAULTHANDLER=1
+          ulimit -c unlimited
+          echo 'Run smoketest'
+          /gpudrive/.venv/bin/python examples/experimental/viz_rollouts.py
+          EOF
+          )"

gpudrive-main/.gitignore

@@ -0,0 +1,258 @@
+/build
+/out
+/build-debug
+/.vs
+/CMakeSettings.json
+/scripts/__pycache__
+/train_src/madrona_escape_room_learn/__pycache__
+.vscode/launch.json
+.vscode/settings.json
+.vscode/tasks.json
+.uv_cache
+
+/examples/benchmarks/results/
+/baselines/ppo/logs/*
+*.sif
+/cloudpickle
+/cloudpickle-3.0.0.dist-info
+*madrona.diff
+/bin
+/zipp*
+/google-cloud-sdk/*
+*.gz
+
+# Data
+hpc/overlay*
+data/raw/*
+data/processed/validation/*
+data/processed/training/*
+data/processed/testing/*
+data/processed/sampled/*
+data/processed/hand_designed/*
+analyze/figures/*
+
+# Logging
+/wandb
+/wandb*
+events.out.tfevents.*
+/runs*
+
+### C++ ###
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+*.csv
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.venv
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+*~
+
+# Environment variables
+# To be manually created using .env.template
+.env
+
+# Logs
+examples/experimental/logs/*
+
+# Sbatch scripts
+*.sh
+
+# Videos
+videos/
+output_videos_larger_dataset/
+output_videos_small_dataset/
+
+# Trained models
+models/
+
+# End of https://www.toptal.com/developers/gitignore/api/python,c++

gpudrive-main/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "external/madrona"]
+	path = external/madrona
+	url = https://github.com/m-naumann/madrona.git
+[submodule "external/json"]
+	path = external/json
+	url = https://github.com/nlohmann/json.git

gpudrive-main/.pre-commit-config.yaml

@@ -0,0 +1,18 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.0.1  # Use the latest version
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/pycqa/flake8
+    rev: 3.9.2  # Use the latest version
+    hooks:
+      - id: flake8
+  - repo: https://github.com/psf/black
+    rev: 22.3.0  # Use the latest version
+    hooks:
+      - id: black
+        args: [--line-length, "79"]

gpudrive-main/.python-version

@@ -0,0 +1 @@
+3.11

gpudrive-main/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.24 FATAL_ERROR) # for madrona
+
+include("${CMAKE_CURRENT_SOURCE_DIR}/external/madrona/cmake/madrona_init.cmake")
+
+project(Madrona3DExample LANGUAGES C CXX)
+
+include(setup)
+include(dependencies)
+
+add_subdirectory(external)
+option(GPUDRIVE_BUILD_TESTS "Build GPUDrive C++ tests" ON)
+
+add_subdirectory(src)
+if (GPUDRIVE_BUILD_TESTS)
+  enable_testing()
+  add_subdirectory(tests)
+endif()

gpudrive-main/Dockerfile

@@ -0,0 +1,52 @@
+# Base image with CUDA and cuDNN support                                                                                      
+FROM nvidia/cuda:12.4.1-cudnn-devel-ubuntu22.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+# Install essential packages
+RUN apt-get update && apt-get install -y -q --no-install-recommends \
+	software-properties-common \
+        build-essential \
+        cmake \
+        git \
+        curl \
+        vim \
+        ca-certificates \
+        libjpeg-dev \
+        libpng-dev \
+        wget \
+        libx11-dev \
+        libxrandr-dev \
+        libxinerama-dev \
+        libxcursor-dev \
+        libxi-dev \
+        mesa-common-dev \
+        libc++1 \
+        openssh-client \
+        ffmpeg \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install uv
+RUN curl -LsSf https://astral.sh/uv/install.sh | env UV_INSTALL_DIR="/usr/bin" sh
+
+# Copy the gpudrive repository
+COPY . /gpudrive
+WORKDIR /gpudrive
+RUN git submodule update --init --recursive
+
+# Install python part using uv
+RUN uv sync --frozen
+
+ENV MADRONA_MWGPU_KERNEL_CACHE=./gpudrive_cache
+
+RUN mkdir build
+WORKDIR /gpudrive/build
+RUN uv run cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_POLICY_VERSION_MINIMUM=3.5 && find external -type f -name "*.tar" -delete
+RUN ln -s /usr/local/cuda/lib64/stubs/libcuda.so /usr/local/cuda/lib64/stubs/libcuda.so.1
+RUN LD_LIBRARY_PATH=/usr/local/cuda/lib64/stubs/:$LD_LIBRARY_PATH uv run make -j
+RUN rm /usr/local/cuda/lib64/stubs/libcuda.so.1
+WORKDIR /gpudrive
+
+CMD ["/bin/bash"]
+LABEL org.opencontainers.image.source=https://github.com/Emerge-Lab/gpudrive

gpudrive-main/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Saman Kazemkhani, Aarav Pandya, Daphne Cornelisse, Brennan Shacklett, Eugene Vinitsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gpudrive-main/README.md

@@ -0,0 +1,383 @@
+GPUDrive
+========
+
+[![Paper](https://img.shields.io/badge/arXiv-2408.01584-b31b1b.svg)](https://arxiv.org/abs/2408.01584)
+[![GitHub CI](https://github.com/Emerge-Lab/gpudrive/actions/workflows/ci.yml/badge.svg)](https://github.com/Emerge-Lab/gpudrive/actions/workflows/ci.yml)
+[![License](https://img.shields.io/github/license/Emerge-Lab/gpudrive)](LICENSE)
+![Python version](https://img.shields.io/badge/Python-3.11-blue)
+
+An extremely fast, data-driven driving simulator written in C++.
+
+## Highlights
+
+- ⚡️ Fast simulation for agent development and evaluation at 1 million FPS through the [Madrona engine](https://madrona-engine.github.io/).
+- 🐍 Provides Python bindings and `gymnasium` wrappers in `torch` and `jax`.
+- 🏃‍➡️ Compatible with the [Waymo Open Motion Dataset](https://github.com/waymo-research/waymo-open-dataset), featuring over 100K scenarios with human demonstrations.
+- 📜 Readily available PPO implementations via [SB3](https://github.com/DLR-RM/stable-baselines3) and [CleanRL](https://github.com/vwxyzjn/cleanrl) / [Pufferlib](https://puffer.ai/).
+- 👀 Easily configure the simulator and agent views.
+- 🎨 Diverse agent types: Vehicles, cyclists and pedestrians.
+
+<div align="center">
+
+| Simulator state                                                  | Agent observation                                                |
+| ---------------------------------------------------------------- | ---------------------------------------------------------------- |
+| <img src="assets/sim_video_7.gif" width="320px">    | <img src="assets/obs_video_7.gif" width="320px"> |
+| <img src="assets/sim_video_0_10.gif" width="320px"> | <img src="assets/obs_video_0_10.gif" width="320px"> |
+
+</div>
+
+For details, see our [paper](https://arxiv.org/abs/2408.01584) and the [introduction tutorials](https://github.com/Emerge-Lab/gpudrive/tree/main/examples/tutorials), which guide you through the basic usage.
+
+## Installation
+
+To build GPUDrive, ensure you have all the required dependencies listed [here](https://github.com/shacklettbp/madrona#dependencies) including CMake, Python, and the CUDA Toolkit. See the details below.
+
+<details> <summary>Dependencies</summary>
+
+- CMake >= 3.24
+- Python >= 3.11
+- CUDA Toolkit >= 12.2 and <= 12.4 (We do not support CUDA versions 12.5+ at this time. Verify your CUDA version using nvcc --version.)
+- On macOS and Windows, install the required dependencies for XCode and Visual Studio C++ tools, respectively.
+
+</details>
+
+After installing the necessary dependencies, clone the repository (don't forget the --recursive flag!):
+
+```bash
+git clone --recursive https://github.com/Emerge-Lab/gpudrive.git
+cd gpudrive
+```
+
+Then, there are two options for building the simulator:
+
+---
+
+<details>
+  <summary>🔧 Option 1. Manual install </summary>
+
+For Linux and macOS, use the following commands:
+
+```bash
+mkdir build
+cd build
+cmake .. -DCMAKE_BUILD_TYPE=Release
+make -j # cores to build with, e.g. 32
+cd ..
+```
+
+For Windows, open the cloned repository in Visual Studio and build the project using the integrated `cmake` functionality.
+
+Next, set up a Python environment
+
+#### With uv (Recommended)
+
+Create a virtual environment and install the Python components of the repository:
+
+```bash
+uv sync --frozen
+```
+
+#### With pyenv
+
+ Create a virtual environment:
+
+ ```bash
+ pyenv virtualenv 3.11 gpudrive
+ pyenv activate gpudrive
+ ```
+
+ Set it for the current project directory (optional):
+
+ ```bash
+ pyenv local gpudrive
+ ```
+
+#### With conda
+
+```bash
+conda env create -f ./environment.yml
+conda activate gpudrive
+```
+
+### Install Python package
+
+Finally, install the Python components of the repository using pip (this step is not required for the `uv` installation):
+
+```bash
+# macOS and Linux.
+pip install -e .
+```
+
+Dependency-groups include `pufferlib`, `sb3`, `vbd`, and `tests`.
+
+```bash
+# On Windows.
+pip install -e . -Cpackages.madrona_escape_room.ext-out-dir=<PATH_TO_YOUR_BUILD_DIR on Windows>
+```
+
+</details>
+
+---
+
+---
+
+<details>
+  <summary> 🐳  Option 2. Docker </summary>
+
+To get started quickly, we provide a Dockerfile in the root directory.
+
+### Prerequisites
+Ensure you have the following installed:
+- [Docker](https://docs.docker.com/get-docker/)
+- [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
+
+### Building the Docker mage
+Once installed, you can build the container with:
+
+```bash
+DOCKER_BUILDKIT=1 docker build --build-arg USE_CUDA=true --tag gpudrive:latest --progress=plain .
+```
+
+### Running the Container
+To run the container with GPU support and shared memory:
+
+```bash
+docker run --gpus all -it --rm --shm-size=20G -v ${PWD}:/workspace gpudrive:latest /bin/bash
+```
+
+</details>
+
+---
+
+Test whether the installation was successful by importing the simulator:
+
+```Python
+import madrona_gpudrive
+```
+
+To avoid compiling on GPU mode everytime, the following environment variable can be set with any custom path. For example, you can store the compiled program in a cache called `gpudrive_cache`:
+
+```bash
+export MADRONA_MWGPU_KERNEL_CACHE=./gpudrive_cache
+```
+
+Please remember that if you make any changes in C++, you need to delete the cache and recompile.
+
+---
+
+<details>
+  <summary>Optional: If you want to use the Madrona viewer in C++</summary>
+
+#### Extra dependencies to use Madrona viewer
+
+  To build the simulator with visualization support on Linux (`build/viewer`), you will need to install X11 and OpenGL development libraries. Equivalent dependencies are already installed by Xcode on macOS. For example, on Ubuntu:
+
+```bash
+  sudo apt install libx11-dev libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev mesa-common-dev libc++1
+```
+
+</details>
+
+---
+
+## Integrations
+
+
+| What                                                                                                    | Info                                                                                                                                                                         | Run                                    | Training SPS |
+| ------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- | ------------------------------ |
+| **IPPO** implementation [SB3](https://github.com/DLR-RM/stable-baselines3/tree/master) | [IPPO](https://proceedings.neurips.cc/paper_files/paper/2022/file/9c1535a02f0ce079433344e14d910597-Paper-Datasets_and_Benchmarks.pdf), [PufferLib](https://arxiv.org/pdf/2406.12905), [Implementation](https://github.com/Emerge-Lab/gpudrive/blob/main/integrations/ppo/puffer) | `python baselines/ppo/ppo_sb3.py`      | 25 - 50K                       |
+| **IPPO** implementation [PufferLib](https://github.com/PufferAI/PufferLib) 🐡                           | [PPO](https://arxiv.org/pdf/2406.12905)                                                   | `python baselines/ppo/ppo_pufferlib.py`       | 100 - 300K                     |
+
+
+## Getting started
+
+To get started, see these entry points:
+
+- Our [intro tutorials](https://github.com/Emerge-Lab/gpudrive/tree/main/examples/tutorials). These tutorials take approximately 30-60 minutes to complete and will guide you through the dataset, simulator, and how to populate the simulator with different types of actors.
+- The [environment docs](https://github.com/Emerge-Lab/gpudrive/tree/main/gpudrive/env) provide detailed info on environment settings and supported features.
+
+<!-- <p align="center">
+  <img src="assets/GPUDrive_docs_flow.png" width="1300" title="Getting started">
+</p> -->
+
+<!-- ## 📈 Tests
+
+To further test the setup, you can run the pytests in the root directory:
+
+```bash
+pytest
+```
+
+To test if the simulator compiled correctly (and python lib did not), try running the headless program from the build directory.
+
+```bash
+cd build
+./headless CPU 1 # Run on CPU, 1 step
+``` -->
+
+## Pre-trained policies
+
+Several pre-trained policies are available via the `PyTorchModelHubMixin` class on 🤗 huggingface_hub.
+
+- **Best Policy (10,000 Scenarios).** The best policy from [Building reliable sim driving agents by scaling self-play](https://arxiv.org/abs/2502.14706) is available here [here](https://huggingface.co/daphne-cornelisse/policy_S10_000_02_27). This policy was trained on 10,000 randomly sampled scenarios from the WOMD training dataset.
+
+- **Alternative Policy (1,000 Scenarios).** A policy trained on 1,000 scenarios can be found [here](https://huggingface.co/daphne-cornelisse/policy_S1000_02_27)
+
+---
+
+> Note: These models were trained with the environment configurations defined in `examples/experimental/config/reliable_agents_params.yaml`, changing environment/observation configurations will affect performance.
+
+---
+
+### Usage
+
+To load a pre-trained policy, use the following:
+```Python
+from gpudrive.networks.late_fusion import NeuralNet
+
+# Load pre-trained model via huggingface_hub
+agent = NeuralNet.from_pretrained("daphne-cornelisse/policy_S10_000_02_27")
+```
+
+See [tutorial 04](https://github.com/Emerge-Lab/gpudrive/tree/main/examples/tutorials/04_use_pretrained_sim_agent.ipynb) for all the details.
+
+## Dataset
+
+### Download the dataset
+
+- Two versions of the dataset are available, a [mini version](https://huggingface.co/datasets/EMERGE-lab/GPUDrive_mini) with a 1000 training files and 300 test/validation files, and a [large dataset](https://huggingface.co/datasets/EMERGE-lab/GPUDrive) with 100k unique scenes.
+- Replace 'GPUDrive_mini' with 'GPUDrive' below if you wish to download the full dataset.
+
+<details>
+  <summary>Download the dataset</summary>
+
+To download the dataset you need the huggingface_hub library
+
+```bash
+pip install huggingface_hub
+```
+
+Then you can download the dataset using python or just `huggingface-cli`.
+
+- **Option 1**: Using Python
+
+```python
+>>> from huggingface_hub import snapshot_download
+>>> snapshot_download(repo_id="EMERGE-lab/GPUDrive_mini", repo_type="dataset", local_dir="data/processed")
+```
+
+- **Option 2**: Use the huggingface-cli
+
+1. Log in to your Hugging Face account:
+
+```bash
+huggingface-cli login
+```
+
+2. Download the dataset:
+
+```bash
+huggingface-cli download EMERGE-lab/GPUDrive_mini --local-dir data/processed --repo-type "dataset"
+```
+
+- **Option 3**: Manual Download
+
+1. Visit https://huggingface.co/datasets/EMERGE-lab/GPUDrive_mini
+2. Navigate to the Files and versions tab.
+3. Download the desired files/directories.
+
+_NOTE_: If you downloaded the full-sized dataset, it is grouped to subdirectories of 10k files each (according to hugging face constraints). In order for the path to work with GPUDrive, you need to run
+
+```python
+python data_utils/post_processing.py #use --help if you've used a custom download path
+```
+
+</details>
+
+### Re-build the dataset
+
+If you wish to manually generate the dataset, GPUDrive is compatible with the complete [Waymo Open Motion Dataset](https://github.com/waymo-research/waymo-open-dataset), which contains well over 100,000 scenarios. To download new files and create scenarios for the simulator, follow the steps below.
+
+<details>
+  <summary>Re-build the dataset in 3 steps</summary>
+
+1. First, head to [https://waymo.com/open/](https://waymo.com/open/) and click on the "download" button a the top. After registering, click on the files from `v1.2.1 March 2024`, the newest version of the dataset at the time of wrting (10/2024). This will lead you a Google Cloud page. From here, you should see a folder structure like this:
+
+```
+waymo_open_dataset_motion_v_1_2_1/
+│
+├── uncompressed/
+│   ├── lidar_and_camera/
+│   ├── scenario/
+│   │   ├── testing_interactive/
+│   │   ├── testing/
+│   │   ├── training_20s/
+│   │   ├── training/
+│   │   ├── validation_interactive/
+│   │   └── validation/
+│   └── tf_example/
+```
+
+2. Now, download files from testing, training and/or validation in the **`scenario`** folder. An easy way to do this is through `gsutil`.  First register using:
+
+```bash
+gcloud auth login
+```
+
+...then run the command below to download the dataset you prefer. For example, to download the validation dataset:
+
+```bash
+gsutil -m cp -r gs://waymo_open_dataset_motion_v_1_2_1/uncompressed/scenario/validation/ data/raw
+```
+
+where `data/raw` is your local storage folder. Note that this can take a while, depending on the size of the dataset you're downloading.
+
+3. The last thing we need to do is convert the raw data to a format that is compatible with the simulator using:
+
+```bash
+python data_utils/process_waymo_files.py '<raw-data-path>' '<storage-path>' '<dataset>'
+```
+
+Note: Due to an open [issue](https://github.com/waymo-research/waymo-open-dataset/issues/868), installation of `waymo-open-dataset-tf-2.12.0` fails for Python 3.11. To use the script, in a separate Python 3.10 environment, run
+
+```bash
+pip install waymo-open-dataset-tf-2-12-0 trimesh[easy] python-fcl
+```
+
+Then for example, if you want to process the validation data, run:
+
+```bash
+python data_utils/process_waymo_files.py 'data/raw/' 'data/processed/' 'validation'
+>>>
+Processing Waymo files: 100%|████████████████████████████████████████████████████████████████| 150/150 [00:05<00:00, 28.18it/s]
+INFO:root:Done!
+```
+
+and that's it!
+
+> **🧐 Caveat**: A single Waymo tfrecord file contains approximately 500 traffic scenarios. Processing speed is about 250 scenes/min on a 16 core CPU. Trying to process the entire validation set for example (150 tfrecords) is a LOT of time.
+
+</details>
+
+### Post-processing
+- Running `python data_utils/postprocessing.py` filters out corrupted files and undoes hugging face directory grouping.
+
+## 📜 Citing GPUDrive
+
+If you use GPUDrive in your research, please cite our ICLR 2025 paper
+```bibtex
+@inproceedings{kazemkhani2025gpudrive,
+      title={GPUDrive: Data-driven, multi-agent driving simulation at 1 million FPS},
+      author={Saman Kazemkhani and Aarav Pandya and Daphne Cornelisse and Brennan Shacklett and Eugene Vinitsky},
+      booktitle={Proceedings of the International Conference on Learning Representations (ICLR)},
+      year={2025},
+      url={https://arxiv.org/abs/2408.01584},
+      eprint={2408.01584},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+}
+```
+
+## Contributing
+
+If you encounter a bug, notice a missing feature, or want to contribute, feel free to create an issue or reach out! We'd be excited to have you involved in the project.

gpudrive-main/README_SHOW.md

@@ -0,0 +1,700 @@
+# Long-Tail Scenario Generation 展示说明
+
+本文档用于展示当前 GPUDrive 长尾场景生成系统的闭环流程、每个阶段的产物路径、文件内容结构，以及这些文件在系统中的作用。
+
+## 1. 整体闭环
+
+当前系统可以概括为四个阶段：
+
+```text
+Search Agent
+  -> 搜索并保存候选危险场景
+
+Converter Agent
+  -> 将仿真轨迹转换成 LLM 可读案例
+
+Evaluator Agent
+  -> 评估场景危险性、自然性、交互合理性和价值
+
+Optimizer Agent
+  -> 根据评估结果推荐下一轮搜索参数
+```
+
+核心思想是：不是只追求“碰撞数量”，而是追求“自然、合理、危险、可解释、有价值”的长尾场景。
+
+## 2. Search Agent 产物
+
+### 文件路径
+
+每一轮搜索会写入一个 round 目录，例如第二轮：
+
+```text
+search_outputs/round_002/search/
+```
+
+多卡并行时，每张 GPU 对应一个 shard：
+
+```text
+search_outputs/round_002/search/shard_000/
+search_outputs/round_002/search/shard_001/
+search_outputs/round_002/search/shard_002/
+search_outputs/round_002/search/shard_003/
+```
+
+每个 shard 下的主要文件：
+
+```text
+events.jsonl
+event_traces.jsonl
+summary.json
+```
+
+### events.jsonl
+
+`events.jsonl` 是轻量级事件索引，一行代表一个候选长尾场景。
+
+典型结构：
+
+```json
+{
+  "shard_id": 0,
+  "batch_idx": 0,
+  "world_idx": 15,
+  "scenario_file": "tfrecord-00475-of-01000_425.json",
+  "controlled_agents": 5,
+  "risk_agents": [1, 4, 38],
+  "collision": true,
+  "near_miss": true,
+  "offroad": true,
+  "first_collision_step": 61,
+  "first_offroad_step": 38,
+  "min_distance_m": 1.3015,
+  "min_distance_step": 63,
+  "min_distance_risk_agent": 4,
+  "min_distance_partner_agent": 21,
+  "collided_agents": [4],
+  "offroad_agents": [4],
+  "goal_agents": 5
+}
+```
+
+作用：
+
+- 快速记录哪些 world 出现了 collision、near-miss、offroad 等事件。
+- 快速统计搜索阶段产生了多少候选危险场景。
+- 作为后续可视化和人工定位的索引。
+
+它回答的是：“这一轮搜到了哪些候选事件？”
+
+### event_traces.jsonl
+
+`event_traces.jsonl` 是更完整的轨迹记录，一行代表一个候选事件。
+
+主要内容包括：
+
+```text
+source:
+  shard_id, batch_idx, world_idx, scenario_file
+
+outcome:
+  collision, near_miss, offroad
+  first_collision_step
+  first_offroad_step
+  min_distance_m
+
+risk_agents:
+  当前 world 中被赋予 risk_taker 风格的车辆 id
+
+agent_traces:
+  每个相关 agent 的逐帧状态
+  包括 x, y, heading, speed, valid, done 等
+
+pairwise_trace:
+  关键车辆对之间的逐帧距离、相对速度、closing speed 等
+
+map_context:
+  事件附近的道路元素、车道线、边界等
+
+quality_metrics:
+  初步自然性和交互质量指标
+```
+
+作用：
+
+- 保存真实评估所需的轨迹数据。
+- 后续不依赖视频判断场景，而是基于轨迹和交互指标进行结构化评估。
+- 为 Converter Agent 提供完整输入。
+
+它回答的是：“这个候选事件具体是怎么发生的？”
+
+### summary.json
+
+`summary.json` 是当前 shard 的搜索统计。
+
+常见内容：
+
+```text
+num_worlds
+num_batches
+num_events
+collision_count
+near_miss_count
+offroad_count
+event_rate
+```
+
+作用：
+
+- 快速查看单个 shard 的搜索结果。
+- 检查搜索任务是否正常完成。
+- 粗略比较不同参数下候选事件数量。
+
+它回答的是：“这一张卡跑出的总体情况如何？”
+
+## 3. Converter Agent 产物
+
+### 文件路径
+
+Converter Agent 将 `event_traces.jsonl` 转换成 LLM 可读案例。
+
+路径示例：
+
+```text
+search_outputs/round_002/llm_cases/shard_000/
+search_outputs/round_002/llm_cases/shard_001/
+search_outputs/round_002/llm_cases/shard_002/
+search_outputs/round_002/llm_cases/shard_003/
+```
+
+主要文件：
+
+```text
+llm_cases.jsonl
+case_cards/
+summary.json
+```
+
+### llm_cases.jsonl
+
+`llm_cases.jsonl` 是 Evaluator Agent 的主要输入，一行代表一个结构化场景案例。
+
+主要结构：
+
+```text
+case_id:
+  唯一案例 id
+
+source:
+  来自哪个 shard、batch、world、scenario_file
+
+outcome:
+  是否 collision、near_miss、offroad
+  首次事件发生 step
+
+primary_pair:
+  当前事件中最关键的一对车辆
+  包括 risk agent、partner agent、选择原因
+
+primary_interaction_metrics:
+  min_clean_distance_m
+  min_ttc_s
+  time_ttc_below_1s
+  event_relative_speed_mps
+  event_closing_speed_mps
+
+timeline:
+  事件前后若干关键时间点的车辆状态
+
+context_agents:
+  周围车辆的简化状态
+
+naturalness_checks:
+  max_speed_mps
+  max_accel_mps2
+  max_yaw_rate_radps
+  large_displacement_flags
+
+map_context:
+  事件附近道路环境
+```
+
+作用：
+
+- 将复杂的多车逐帧轨迹压缩成 LLM 和规则系统都能理解的结构化文本/JSON。
+- 过滤 `done=true` 后的污染帧，并要求 `valid=true`，避免仿真结束后的无效位置��响评估。
+- 自动选择 primary pair，让评估聚焦于最关键的交互车辆对。
+
+它回答的是：“如何把仿真轨迹变成可评估的交通事件描述？”
+
+### primary pair 的意义
+
+一个 world 中可能有很多车，但真正决定场景价值的通常是一对关键交互车辆。
+
+primary pair 的选择优先级：
+
+```text
+1. risk agent 直接参与碰撞的车辆对
+2. 最小距离对应的 risk-agent 车辆对
+3. 碰撞车辆对
+4. 其他最接近的交互车辆对
+```
+
+作用：
+
+- 让 Evaluator Agent 聚焦主要冲突对象。
+- 避免被无关车辆干扰。
+- 让 LLM 评估时更容易判断这个事件是否自然、合理、有价值。
+
+### case_cards/
+
+`case_cards/` 保存 Markdown 版案例卡。
+
+示例路径：
+
+```text
+search_outputs/round_002/llm_cases/shard_000/case_cards/
+```
+
+作用：
+
+- 给人快速浏览。
+- 展示单个事件的关键指标、时间线、车辆关系。
+- 可用于人工抽查 Evaluator Agent 的判断是否合理。
+
+### summary.json
+
+记录转换统计，例如：
+
+```text
+input_events
+converted_cases
+written_cards
+skipped_cases
+```
+
+作用：
+
+- 检查转换是否完整。
+- 对比 Search Agent 产出的事件数量和最终可评估 case 数量。
+
+## 4. Evaluator Agent 产物
+
+### 文件路径
+
+Evaluator Agent 对 `llm_cases.jsonl` 进行规则评估和 LLM 评估。
+
+路径示例：
+
+```text
+search_outputs/round_002/evaluator_agent/shard_000/
+search_outputs/round_002/evaluator_agent/shard_001/
+search_outputs/round_002/evaluator_agent/shard_002/
+search_outputs/round_002/evaluator_agent/shard_003/
+```
+
+主要文件：
+
+```text
+all_evaluations.jsonl
+accepted_cases.jsonl
+rejected_cases.jsonl
+summary.json
+optimizer_metrics.json
+raw_responses/
+```
+
+### all_evaluations.jsonl
+
+`all_evaluations.jsonl` 保存所有案例的完整评估结果。
+
+主要结构：
+
+```text
+case:
+  原始 llm case
+
+local_eval:
+  本地规则评估结果
+
+llm_eval:
+  DeepSeek / LLM 返回的评估结果
+
+final_eval:
+  融合后的最终评估结果
+```
+
+`final_eval` 中的重要字段：
+
+```text
+accepted:
+  是否接受该场景
+
+high_value:
+  是否为高价值场景
+
+criticality_score:
+  危险程度
+
+naturalness_score:
+  运动自然性
+
+interaction_score:
+  交互合理性
+
+scenario_value_score:
+  场景价值
+
+danger_level:
+  危险等级
+
+scenario_type:
+  场景类型
+
+artifact_flags:
+  伪影标记
+
+rejection_reasons:
+  拒绝原因
+
+optimization_feedback:
+  给 Optimizer Agent 的反馈信号
+```
+
+作用：
+
+- 给每个场景一个结构化评估结果。
+- 判断场景是否真正危险、自然、合理。
+- 为后续筛选和优化提供数据。
+
+它回答的是：“这个场景到底有没有价值？”
+
+### accepted_cases.jsonl
+
+保存通过评估的案例。
+
+通过条件不是简单的“发生碰撞”，而是综合考虑：
+
+```text
+危险性
+运动自然性
+交互合理性
+risk agent 是否真正参与
+是否存在明显伪影
+场景是否有分析价值
+```
+
+作用：
+
+- 作为最终可展示、可保存、可进一步分析的高质量候选集。
+- 用于后续可视化或构建长尾数据集。
+
+### rejected_cases.jsonl
+
+保存被拒绝的案例。
+
+常见拒绝原因：
+
+```text
+车辆运动不自然
+速度或加速度异常
+车辆轨迹有跳变
+risk agent 没有真正参与冲突
+offroad 早于 collision，场景价值较低
+done 后状态污染
+碰撞缺少交互因果
+```
+
+作用：
+
+- 帮助分析当前搜索策略的缺陷。
+- 给 Optimizer Agent 提供负反馈。
+- 避免系统只追求碰撞数量而产生大量低质量事件。
+
+### optimizer_metrics.json
+
+这是 Evaluator Agent 输出给 Optimizer Agent 的核心文件。
+
+路径示例：
+
+```text
+search_outputs/round_002/evaluator_agent/shard_000/optimizer_metrics.json
+```
+
+核心结构：
+
+```text
+current_search_parameters:
+  risk_collision_weight
+  risk_goal_weight
+  risk_offroad_weight
+  risk_agents_per_world
+  normal_mode
+  deterministic
+
+objective_metrics:
+  total_evaluated
+  accepted_count
+  rejected_count
+  high_value_count
+  accepted_rate
+  high_value_rate
+  natural_critical_rate
+  risk_direct_involved_rate
+  risk_direct_accept_rate
+  hard_artifact_record_rate
+  semantic_diversity_entropy
+  composite_objective
+
+score_stats:
+  criticality_score
+  naturalness_score
+  interaction_score
+  scenario_value_score
+
+metric_stats:
+  clean_min_distance_m
+  min_ttc_s
+  event_relative_speed_mps
+  event_closing_speed_mps
+  max_speed_mps
+  max_accel_mps2
+  max_yaw_rate_radps
+
+counts:
+  scenario_type
+  artifact_flags
+  rejection_reasons
+  optimization_feedback
+
+optimizer_ready_records:
+  top cases used as compact feedback examples
+```
+
+作用：
+
+- 汇总一个 shard 的整体质量。
+- 作为 Optimizer Agent 的训练样本。
+- 衡量一轮搜索是否比上一轮更好。
+
+它回答的是：“当前这组搜索参数整体表现怎么样？”
+
+## 5. Optimizer Agent 产物
+
+### 文件路径
+
+Optimizer Agent 读取一轮或多轮的 `optimizer_metrics.json`，学习参数到质量指标的映射，并推荐下一轮搜索参数。
+
+路径示例：
+
+```text
+search_outputs/round_002/optimizer_agent/mlp_next/
+```
+
+主要文件：
+
+```text
+optimizer_plan.json
+candidate_predictions.jsonl
+best_recommendation.env
+recommended_search_commands.sh
+```
+
+### optimizer_plan.json
+
+完整优化计划。
+
+主要内容：
+
+```text
+metrics_paths:
+  使用了哪些 optimizer_metrics.json
+
+history_samples:
+  历史搜索参数和对应质量指标
+
+candidate_grid:
+  当前可搜索的参数空间
+
+training:
+  MLP surrogate model 的训练状态
+
+recommendations:
+  推荐的下一轮参数
+```
+
+作用：
+
+- 记录 Optimizer Agent 的完整决策过程。
+- 可解释为什么推荐下一组参数。
+- 支持复盘每一轮闭环优化。
+
+### candidate_predictions.jsonl
+
+保存每个候选参数组合的预测结果。
+
+典型字段：
+
+```text
+risk_collision_weight
+risk_goal_weight
+risk_offroad_weight
+risk_agents_per_world
+normal_mode
+deterministic
+predicted_composite_objective
+predicted_accepted_rate
+predicted_high_value_rate
+predicted_hard_artifact_rate
+```
+
+作用：
+
+- 查看 MLP surrogate model 对不同参数组合的预测。
+- 分析哪些参数更可能生成高质量长尾场景。
+- 支持 top-k 推荐和 exploration。
+
+### best_recommendation.env
+
+下一轮搜索可直接加载的参数文件。
+
+示例：
+
+```bash
+RISK_COLLISION_WEIGHT=-0.2
+RISK_GOAL_WEIGHT=1.6
+RISK_OFFROAD_WEIGHT=-0.8
+RISK_AGENTS_PER_WORLD=1
+NORMAL_MODE=expert
+DETERMINISTIC=0
+```
+
+作用：
+
+- 直接用于下一轮 Search Agent。
+- 闭环系统中最直接的优化输出。
+
+### recommended_search_commands.sh
+
+自动生成的搜索命令。
+
+作用：
+
+- 方便直接提交下一轮实验。
+- 避免手工复制参数出错。
+
+## 6. 每轮之间如何比较是否变好
+
+不要只看碰撞数量。碰撞数量变多只说明候选池变大，不代表场景质量一定更好。
+
+核心比较文件：
+
+```text
+search_outputs/round_001/evaluator_agent/shard_*/optimizer_metrics.json
+search_outputs/round_002/evaluator_agent/shard_*/optimizer_metrics.json
+```
+
+推荐展示指标：
+
+```text
+composite_objective
+  主指标，越高越好
+
+accepted_rate
+  Evaluator Agent 接受比例，越高越好
+
+high_value_rate
+  高价值场景比例，越高越好
+
+natural_critical_rate
+  同时危险且自然的场景比例，越高越好
+
+risk_direct_accept_rate
+  risk agent 直接参与并被接受的比例，越高越好
+
+hard_artifact_record_rate
+  明显伪影比例，越低越好
+
+semantic_diversity_entropy
+  场景类型多样性，过低说明模式坍塌
+```
+
+如果第二轮出现：
+
+```text
+LLM case 数量增加
+accepted_rate 不下降或上升
+high_value_rate 上升
+natural_critical_rate 上升
+hard_artifact_record_rate 不上升或下降
+composite_objective 上升
+```
+
+则可以说明闭环优化在产生更高质量的长尾场景。
+
+## 7. 展示时推荐讲法
+
+可以这样概括：
+
+```text
+我们首先基于 GPUDrive 并行运行大量世界，并使用 reward-conditioned policy
+给车辆赋予不同驾驶风格。Search Agent 会搜索 collision、near-miss、
+offroad 等候选长尾事件，并保存轻量事件索引 events.jsonl 和完整轨迹
+event_traces.jsonl。
+
+随后，Converter Agent 将复杂的多车逐帧轨迹转换为 LLM 可读的结构化案例
+llm_cases.jsonl。转换过程中会清理 done 后的无效帧，并自动选择最关键的
+primary pair。
+
+Evaluator Agent 进一步从危险性、运动自然性、交互合理性、场景价值和伪影率
+等维度评估每个案例，输出 accepted/rejected cases 和 optimizer_metrics.json。
+
+最后，Optimizer Agent 使用这些评估指标训练一个 MLP surrogate model，
+预测不同 reward-condition 参数的效果，并推荐下一轮搜索参数。这样系统形成
+自动生成、自动评估、自动优化的闭环多 Agent 长尾数据生成流程。
+```
+
+一句话总结：
+
+```text
+我们的目标不是生成更多碰撞，而是自动生成更多自然、合理、危险且有价值的长尾交互场景。
+```
+
+## 8. 各文件一句话速查
+
+```text
+events.jsonl
+  轻量事件索引，记录搜到了哪些候选危险事件。
+
+event_traces.jsonl
+  完整轨迹记录，保存评估所需的多车状态和交互数据。
+
+llm_cases.jsonl
+  LLM 可读案例，将复杂轨迹压缩成结构化交通事件。
+
+case_cards/
+  Markdown 案例卡，方便人工快速浏览。
+
+all_evaluations.jsonl
+  所有案例的完整评估结果。
+
+accepted_cases.jsonl
+  通过评估的高质量候选场景。
+
+rejected_cases.jsonl
+  被拒绝的低质量或伪影场景。
+
+optimizer_metrics.json
+  当前搜索参数的质量汇总，是 Optimizer Agent 的输入。
+
+optimizer_plan.json
+  Optimizer Agent 的完整优化计划。
+
+candidate_predictions.jsonl
+  每个候选参数组合的预测效果。
+
+best_recommendation.env
+  下一轮搜索直接加载的推荐参数。
+
+recommended_search_commands.sh
+  下一轮可直接提交的搜索命令。
+```

gpudrive-main/assets/agent_collision.obj

@@ -0,0 +1,212 @@
+# Blender 3.6.0
+# www.blender.org
+o Sphere
+v 0.000000 0.450000 1.698761
+v 0.000000 0.779423 1.369338
+v 0.000000 0.900000 0.919338
+v 0.000000 0.779423 0.469338
+v 0.000000 0.450000 0.139915
+v 0.389711 0.225000 1.698761
+v 0.675000 0.389711 1.369338
+v 0.779423 0.450000 0.919338
+v 0.675000 0.389711 0.469338
+v 0.389711 0.225000 0.139915
+v 0.389711 -0.225000 1.698761
+v 0.675000 -0.389711 1.369338
+v 0.779423 -0.450000 0.919338
+v 0.675000 -0.389711 0.469338
+v 0.389711 -0.225000 0.139915
+v -0.000000 -0.450000 1.698761
+v -0.000000 -0.779423 1.369338
+v -0.000000 -0.900000 0.919338
+v -0.000000 -0.779423 0.469338
+v -0.000000 -0.450000 0.139915
+v 0.000000 0.000000 1.819338
+v -0.389711 -0.225000 1.698761
+v -0.675000 -0.389711 1.369338
+v -0.779423 -0.450000 0.919338
+v -0.675000 -0.389711 0.469338
+v -0.389711 -0.225000 0.139915
+v -0.389711 0.225000 1.698761
+v -0.675000 0.389712 1.369338
+v -0.779423 0.450000 0.919338
+v -0.675000 0.389712 0.469338
+v -0.389711 0.225000 0.139915
+v 0.000000 0.000000 0.019338
+s 0
+f 5 4 9 10
+f 3 2 7 8
+f 1 21 6
+f 32 5 10
+f 4 3 8 9
+f 2 1 6 7
+f 32 10 15
+f 9 8 13 14
+f 7 6 11 12
+f 10 9 14 15
+f 8 7 12 13
+f 6 21 11
+f 32 15 20
+f 14 13 18 19
+f 12 11 16 17
+f 15 14 19 20
+f 13 12 17 18
+f 11 21 16
+f 32 20 26
+f 19 18 24 25
+f 17 16 22 23
+f 20 19 25 26
+f 18 17 23 24
+f 16 21 22
+f 25 24 29 30
+f 23 22 27 28
+f 26 25 30 31
+f 24 23 28 29
+f 22 21 27
+f 32 26 31
+f 28 27 1 2
+f 31 30 4 5
+f 29 28 2 3
+f 27 21 1
+f 32 31 5
+f 30 29 3 4
+o Sphere.001
+v -0.859505 0.778871 0.910019
+v -0.859505 0.877698 0.811193
+v -0.859505 0.913871 0.676193
+v -0.859505 0.877698 0.541193
+v -0.859505 0.778871 0.442366
+v -0.742592 0.711371 0.910019
+v -0.657005 0.760784 0.811193
+v -0.625678 0.778871 0.676193
+v -0.657005 0.760784 0.541193
+v -0.742592 0.711371 0.442366
+v -0.742592 0.576371 0.910019
+v -0.657005 0.526958 0.811193
+v -0.625678 0.508871 0.676193
+v -0.657005 0.526958 0.541193
+v -0.742592 0.576371 0.442366
+v -0.859505 0.508871 0.910019
+v -0.859505 0.410044 0.811193
+v -0.859505 0.373871 0.676193
+v -0.859505 0.410044 0.541193
+v -0.859505 0.508871 0.442366
+v -0.859505 0.643871 0.946193
+v -0.976418 0.576371 0.910019
+v -1.062005 0.526958 0.811193
+v -1.093332 0.508871 0.676193
+v -1.062005 0.526958 0.541193
+v -0.976418 0.576371 0.442366
+v -0.976418 0.711371 0.910019
+v -1.062005 0.760785 0.811193
+v -1.093332 0.778871 0.676193
+v -1.062005 0.760785 0.541193
+v -0.976418 0.711371 0.442366
+v -0.859505 0.643871 0.406193
+s 0
+f 37 36 41 42
+f 35 34 39 40
+f 33 53 38
+f 64 37 42
+f 36 35 40 41
+f 34 33 38 39
+f 64 42 47
+f 41 40 45 46
+f 39 38 43 44
+f 42 41 46 47
+f 40 39 44 45
+f 38 53 43
+f 64 47 52
+f 46 45 50 51
+f 44 43 48 49
+f 47 46 51 52
+f 45 44 49 50
+f 43 53 48
+f 64 52 58
+f 51 50 56 57
+f 49 48 54 55
+f 52 51 57 58
+f 50 49 55 56
+f 48 53 54
+f 57 56 61 62
+f 55 54 59 60
+f 58 57 62 63
+f 56 55 60 61
+f 54 53 59
+f 64 58 63
+f 60 59 33 34
+f 63 62 36 37
+f 61 60 34 35
+f 59 53 33
+f 64 63 37
+f 62 61 35 36
+o Sphere.002
+v 0.859505 0.778871 0.910019
+v 0.859505 0.877698 0.811193
+v 0.859505 0.913871 0.676193
+v 0.859505 0.877698 0.541193
+v 0.859505 0.778871 0.442366
+v 0.976418 0.711371 0.910019
+v 1.062005 0.760784 0.811193
+v 1.093332 0.778871 0.676193
+v 1.062005 0.760784 0.541193
+v 0.976418 0.711371 0.442366
+v 0.976418 0.576371 0.910019
+v 1.062005 0.526958 0.811193
+v 1.093332 0.508871 0.676193
+v 1.062005 0.526958 0.541193
+v 0.976418 0.576371 0.442366
+v 0.859505 0.508871 0.910019
+v 0.859505 0.410044 0.811193
+v 0.859505 0.373871 0.676193
+v 0.859505 0.410044 0.541193
+v 0.859505 0.508871 0.442366
+v 0.859505 0.643871 0.946193
+v 0.742592 0.576371 0.910019
+v 0.657005 0.526958 0.811193
+v 0.625678 0.508871 0.676193
+v 0.657005 0.526958 0.541193
+v 0.742592 0.576371 0.442366
+v 0.742592 0.711371 0.910019
+v 0.657005 0.760785 0.811193
+v 0.625678 0.778871 0.676193
+v 0.657005 0.760785 0.541193
+v 0.742592 0.711371 0.442366
+v 0.859505 0.643871 0.406193
+s 0
+f 69 68 73 74
+f 67 66 71 72
+f 65 85 70
+f 96 69 74
+f 68 67 72 73
+f 66 65 70 71
+f 96 74 79
+f 73 72 77 78
+f 71 70 75 76
+f 74 73 78 79
+f 72 71 76 77
+f 70 85 75
+f 96 79 84
+f 78 77 82 83
+f 76 75 80 81
+f 79 78 83 84
+f 77 76 81 82
+f 75 85 80
+f 96 84 90
+f 83 82 88 89
+f 81 80 86 87
+f 84 83 89 90
+f 82 81 87 88
+f 80 85 86
+f 89 88 93 94
+f 87 86 91 92
+f 90 89 94 95
+f 88 87 92 93
+f 86 85 91
+f 96 90 95
+f 92 91 65 66
+f 95 94 68 69
+f 93 92 66 67
+f 91 85 65
+f 96 95 69
+f 94 93 67 68

gpudrive-main/assets/agent_collision_simplified.obj

@@ -0,0 +1,18 @@
+# Blender 3.4.1
+# www.blender.org
+o Cube
+v -1.000000 -1.000000 0.000000
+v -1.000000 -1.000000 2.000000
+v -1.000000 1.000000 0.000000
+v -1.000000 1.000000 2.000000
+v 1.000000 -1.000000 0.000000
+v 1.000000 -1.000000 2.000000
+v 1.000000 1.000000 0.000000
+v 1.000000 1.000000 2.000000
+s 0
+f 1 2 4 3
+f 3 4 8 7
+f 7 8 6 5
+f 5 6 2 1
+f 3 7 5 1
+f 8 4 2 6

gpudrive-main/assets/cube_collision.obj

@@ -0,0 +1,18 @@
+# Blender 3.3.1
+# www.blender.org
+o Cube
+v 1.000000 1.000000 1.000000
+v 1.000000 1.000000 -1.000000
+v 1.000000 -1.000000 1.000000
+v 1.000000 -1.000000 -1.000000
+v -1.000000 1.000000 1.000000
+v -1.000000 1.000000 -1.000000
+v -1.000000 -1.000000 1.000000
+v -1.000000 -1.000000 -1.000000
+s 0
+f 1 5 7 3
+f 4 3 7 8
+f 8 7 5 6
+f 6 2 4 8
+f 2 1 3 4
+f 6 5 1 2

gpudrive-main/assets/cube_render.obj

@@ -0,0 +1,44 @@
+# Blender 3.3.1
+# www.blender.org
+o Cube
+v 1.000000 1.000000 1.000000
+v 1.000000 1.000000 -1.000000
+v 1.000000 -1.000000 1.000000
+v 1.000000 -1.000000 -1.000000
+v -1.000000 1.000000 1.000000
+v -1.000000 1.000000 -1.000000
+v -1.000000 -1.000000 1.000000
+v -1.000000 -1.000000 -1.000000
+vn -0.0000 -0.0000 1.0000
+vn -0.0000 -1.0000 -0.0000
+vn -1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vn 1.0000 -0.0000 -0.0000
+vn -0.0000 1.0000 -0.0000
+vt 0.625000 0.500000
+vt 0.375000 0.500000
+vt 0.625000 0.750000
+vt 0.375000 0.750000
+vt 0.875000 0.500000
+vt 0.625000 0.250000
+vt 0.125000 0.500000
+vt 0.375000 0.250000
+vt 0.875000 0.750000
+vt 0.625000 1.000000
+vt 0.625000 0.000000
+vt 0.375000 0.000000
+vt 0.375000 1.000000
+vt 0.125000 0.750000
+s 0
+f 5/5/1 3/3/1 1/1/1
+f 3/3/2 8/13/2 4/4/2
+f 7/11/3 6/8/3 8/12/3
+f 2/2/4 8/14/4 6/7/4
+f 1/1/5 4/4/5 2/2/5
+f 5/6/6 2/2/6 6/8/6
+f 5/5/1 7/9/1 3/3/1
+f 3/3/2 7/10/2 8/13/2
+f 7/11/3 5/6/3 6/8/3
+f 2/2/4 4/4/4 8/14/4
+f 1/1/5 3/3/5 4/4/5
+f 5/6/6 1/1/6 2/2/6

gpudrive-main/assets/cylinder_collision.obj

@@ -0,0 +1,54 @@
+# Blender 3.3.1
+# www.blender.org
+o Cylinder
+v 0.000000 1.000000 -1.500000
+v 0.000000 1.000000 1.500000
+v 0.382683 0.923880 -1.500000
+v 0.382683 0.923880 1.500000
+v 0.707107 0.707107 -1.500000
+v 0.707107 0.707107 1.500000
+v 0.923880 0.382683 -1.500000
+v 0.923880 0.382683 1.500000
+v 1.000000 0.000000 -1.500000
+v 1.000000 0.000000 1.500000
+v 0.923880 -0.382683 -1.500000
+v 0.923880 -0.382683 1.500000
+v 0.707107 -0.707107 -1.500000
+v 0.707107 -0.707107 1.500000
+v 0.382683 -0.923880 -1.500000
+v 0.382683 -0.923880 1.500000
+v 0.000000 -1.000000 -1.500000
+v 0.000000 -1.000000 1.500000
+v -0.382683 -0.923880 -1.500000
+v -0.382683 -0.923880 1.500000
+v -0.707107 -0.707107 -1.500000
+v -0.707107 -0.707107 1.500000
+v -0.923880 -0.382683 -1.500000
+v -0.923880 -0.382683 1.500000
+v -1.000000 0.000000 -1.500000
+v -1.000000 0.000000 1.500000
+v -0.923880 0.382683 -1.500000
+v -0.923880 0.382683 1.500000
+v -0.707107 0.707107 -1.500000
+v -0.707107 0.707107 1.500000
+v -0.382683 0.923880 -1.500000
+v -0.382683 0.923880 1.500000
+s 0
+f 1 2 4 3
+f 3 4 6 5
+f 5 6 8 7
+f 7 8 10 9
+f 9 10 12 11
+f 11 12 14 13
+f 13 14 16 15
+f 15 16 18 17
+f 17 18 20 19
+f 19 20 22 21
+f 21 22 24 23
+f 23 24 26 25
+f 25 26 28 27
+f 27 28 30 29
+f 4 2 32 30 28 26 24 22 20 18 16 14 12 10 8 6
+f 29 30 32 31
+f 31 32 2 1
+f 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31

gpudrive-main/assets/cylinder_render.obj

@@ -0,0 +1,180 @@
+# Blender 3.3.1
+# www.blender.org
+o Cylinder
+v 0.000000 1.000000 -1.500000
+v 0.000000 1.000000 1.500000
+v 0.382683 0.923880 -1.500000
+v 0.382683 0.923880 1.500000
+v 0.707107 0.707107 -1.500000
+v 0.707107 0.707107 1.500000
+v 0.923880 0.382683 -1.500000
+v 0.923880 0.382683 1.500000
+v 1.000000 0.000000 -1.500000
+v 1.000000 0.000000 1.500000
+v 0.923880 -0.382683 -1.500000
+v 0.923880 -0.382683 1.500000
+v 0.707107 -0.707107 -1.500000
+v 0.707107 -0.707107 1.500000
+v 0.382683 -0.923880 -1.500000
+v 0.382683 -0.923880 1.500000
+v 0.000000 -1.000000 -1.500000
+v 0.000000 -1.000000 1.500000
+v -0.382683 -0.923880 -1.500000
+v -0.382683 -0.923880 1.500000
+v -0.707107 -0.707107 -1.500000
+v -0.707107 -0.707107 1.500000
+v -0.923880 -0.382683 -1.500000
+v -0.923880 -0.382683 1.500000
+v -1.000000 0.000000 -1.500000
+v -1.000000 0.000000 1.500000
+v -0.923880 0.382683 -1.500000
+v -0.923880 0.382683 1.500000
+v -0.707107 0.707107 -1.500000
+v -0.707107 0.707107 1.500000
+v -0.382683 0.923880 -1.500000
+v -0.382683 0.923880 1.500000
+vn 0.1951 0.9808 -0.0000
+vn 0.5556 0.8315 -0.0000
+vn 0.8315 0.5556 -0.0000
+vn 0.9808 0.1951 -0.0000
+vn 0.9808 -0.1951 -0.0000
+vn 0.8315 -0.5556 -0.0000
+vn 0.5556 -0.8315 -0.0000
+vn 0.1951 -0.9808 -0.0000
+vn -0.1951 -0.9808 -0.0000
+vn -0.5556 -0.8315 -0.0000
+vn -0.8315 -0.5556 -0.0000
+vn -0.9808 -0.1951 -0.0000
+vn -0.9808 0.1951 -0.0000
+vn -0.8315 0.5556 -0.0000
+vn -0.0000 -0.0000 1.0000
+vn -0.5556 0.8315 -0.0000
+vn -0.1951 0.9808 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vt 1.000000 0.500000
+vt 0.000000 0.500000
+vt 0.750000 0.490000
+vt 1.000000 1.000000
+vt 0.250000 0.490000
+vt 0.000000 1.000000
+vt 0.937500 0.500000
+vt 0.841844 0.471731
+vt 0.937500 1.000000
+vt 0.341844 0.471731
+vt 0.875000 0.500000
+vt 0.919706 0.419706
+vt 0.875000 1.000000
+vt 0.419706 0.419706
+vt 0.812500 0.500000
+vt 0.971731 0.341844
+vt 0.812500 1.000000
+vt 0.471731 0.341844
+vt 0.750000 0.500000
+vt 0.990000 0.250000
+vt 0.750000 1.000000
+vt 0.490000 0.250000
+vt 0.687500 0.500000
+vt 0.971731 0.158156
+vt 0.687500 1.000000
+vt 0.471731 0.158156
+vt 0.625000 0.500000
+vt 0.919706 0.080294
+vt 0.625000 1.000000
+vt 0.419706 0.080294
+vt 0.562500 0.500000
+vt 0.841844 0.028269
+vt 0.562500 1.000000
+vt 0.341844 0.028269
+vt 0.500000 0.500000
+vt 0.750000 0.010000
+vt 0.500000 1.000000
+vt 0.250000 0.010000
+vt 0.437500 0.500000
+vt 0.658156 0.028269
+vt 0.437500 1.000000
+vt 0.158156 0.028269
+vt 0.375000 0.500000
+vt 0.580294 0.080294
+vt 0.375000 1.000000
+vt 0.080294 0.080294
+vt 0.312500 0.500000
+vt 0.528269 0.158156
+vt 0.312500 1.000000
+vt 0.028269 0.158156
+vt 0.250000 0.500000
+vt 0.510000 0.250000
+vt 0.250000 1.000000
+vt 0.010000 0.250000
+vt 0.187500 0.500000
+vt 0.528269 0.341844
+vt 0.187500 1.000000
+vt 0.028269 0.341844
+vt 0.125000 0.500000
+vt 0.580294 0.419706
+vt 0.080294 0.419706
+vt 0.125000 1.000000
+vt 0.062500 0.500000
+vt 0.658156 0.471731
+vt 0.158156 0.471731
+vt 0.062500 1.000000
+s 0
+f 2/4/1 3/7/1 1/1/1
+f 4/9/2 5/11/2 3/7/2
+f 6/13/3 7/15/3 5/11/3
+f 8/17/4 9/19/4 7/15/4
+f 10/21/5 11/23/5 9/19/5
+f 12/25/6 13/27/6 11/23/6
+f 14/29/7 15/31/7 13/27/7
+f 16/33/8 17/35/8 15/31/8
+f 18/37/9 19/39/9 17/35/9
+f 20/41/10 21/43/10 19/39/10
+f 22/45/11 23/47/11 21/43/11
+f 24/49/12 25/51/12 23/47/12
+f 26/53/13 27/55/13 25/51/13
+f 28/57/14 29/59/14 27/55/14
+f 22/46/15 14/30/15 6/14/15
+f 30/62/16 31/63/16 29/59/16
+f 32/66/17 1/2/17 31/63/17
+f 15/32/18 23/48/18 31/64/18
+f 2/4/1 4/9/1 3/7/1
+f 4/9/2 6/13/2 5/11/2
+f 6/13/3 8/17/3 7/15/3
+f 8/17/4 10/21/4 9/19/4
+f 10/21/5 12/25/5 11/23/5
+f 12/25/6 14/29/6 13/27/6
+f 14/29/7 16/33/7 15/31/7
+f 16/33/8 18/37/8 17/35/8
+f 18/37/9 20/41/9 19/39/9
+f 20/41/10 22/45/10 21/43/10
+f 22/45/11 24/49/11 23/47/11
+f 24/49/12 26/53/12 25/51/12
+f 26/53/13 28/57/13 27/55/13
+f 28/57/14 30/62/14 29/59/14
+f 6/14/15 4/10/15 2/5/15
+f 2/5/15 32/65/15 30/61/15
+f 30/61/15 28/58/15 26/54/15
+f 26/54/15 24/50/15 22/46/15
+f 22/46/15 20/42/15 18/38/15
+f 18/38/15 16/34/15 14/30/15
+f 14/30/15 12/26/15 10/22/15
+f 10/22/15 8/18/15 6/14/15
+f 6/14/15 2/5/15 30/61/15
+f 30/61/15 26/54/15 22/46/15
+f 22/46/15 18/38/15 14/30/15
+f 14/30/15 10/22/15 6/14/15
+f 6/14/15 30/61/15 22/46/15
+f 30/62/16 32/66/16 31/63/16
+f 32/66/17 2/6/17 1/2/17
+f 31/64/18 1/3/18 3/8/18
+f 3/8/18 5/12/18 7/16/18
+f 7/16/18 9/20/18 11/24/18
+f 11/24/18 13/28/18 15/32/18
+f 15/32/18 17/36/18 19/40/18
+f 19/40/18 21/44/18 23/48/18
+f 23/48/18 25/52/18 27/56/18
+f 27/56/18 29/60/18 31/64/18
+f 31/64/18 3/8/18 7/16/18
+f 7/16/18 11/24/18 15/32/18
+f 15/32/18 19/40/18 23/48/18
+f 23/48/18 27/56/18 31/64/18
+f 31/64/18 7/16/18 15/32/18

gpudrive-main/assets/elongated_collision.obj

@@ -0,0 +1,18 @@
+# Blender 3.3.1
+# www.blender.org
+o Cube
+v -4.000000 -0.750000 -1.000000
+v -4.000000 -0.750000 1.000000
+v -4.000000 0.750000 -1.000000
+v -4.000000 0.750000 1.000000
+v 4.000000 -0.750000 -1.000000
+v 4.000000 -0.750000 1.000000
+v 4.000000 0.750000 -1.000000
+v 4.000000 0.750000 1.000000
+s 0
+f 1 2 4 3
+f 3 4 8 7
+f 7 8 6 5
+f 5 6 2 1
+f 3 7 5 1
+f 8 4 2 6

gpudrive-main/assets/elongated_render.obj

@@ -0,0 +1,44 @@
+# Blender 3.3.1
+# www.blender.org
+o Cube
+v -4.000000 -0.750000 -1.000000
+v -4.000000 -0.750000 1.000000
+v -4.000000 0.750000 -1.000000
+v -4.000000 0.750000 1.000000
+v 4.000000 -0.750000 -1.000000
+v 4.000000 -0.750000 1.000000
+v 4.000000 0.750000 -1.000000
+v 4.000000 0.750000 1.000000
+vn -1.0000 -0.0000 -0.0000
+vn -0.0000 1.0000 -0.0000
+vn 1.0000 -0.0000 -0.0000
+vn -0.0000 -1.0000 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vn -0.0000 -0.0000 1.0000
+vt 0.375000 0.000000
+vt 0.375000 1.000000
+vt 0.125000 0.750000
+vt 0.625000 0.000000
+vt 0.625000 1.000000
+vt 0.875000 0.750000
+vt 0.125000 0.500000
+vt 0.375000 0.250000
+vt 0.625000 0.250000
+vt 0.875000 0.500000
+vt 0.375000 0.750000
+vt 0.625000 0.750000
+vt 0.375000 0.500000
+vt 0.625000 0.500000
+s 0
+f 2/4/1 3/8/1 1/1/1
+f 4/9/2 7/13/2 3/8/2
+f 8/14/3 5/11/3 7/13/3
+f 6/12/4 1/2/4 5/11/4
+f 7/13/5 1/3/5 3/7/5
+f 4/10/6 6/12/6 8/14/6
+f 2/4/1 4/9/1 3/8/1
+f 4/9/2 8/14/2 7/13/2
+f 8/14/3 6/12/3 5/11/3
+f 6/12/4 2/5/4 1/2/4
+f 7/13/5 5/11/5 1/3/5
+f 4/10/6 2/6/6 6/12/6

gpudrive-main/assets/plane.obj

@@ -0,0 +1,15 @@
+# Blender 3.3.1
+# www.blender.org
+o Plane
+v -10000.0 -10000.0 0.000000
+v 10000.0 -10000.0 0.000000
+v -10000.0 10000.0 0.000000
+v 10000.0 10000.0 0.000000
+vn -0.0000 -0.0000 1.0000
+vt 0.000000 0.000000
+vt 1000.000000 0.000000
+vt 0.000000 1000.000000
+vt 1000.000000 1000.000000
+s 0
+f 2/2/1 3/3/1 1/1/1
+f 2/2/1 4/4/1 3/3/1

gpudrive-main/assets/ramp_collision.obj

@@ -0,0 +1,15 @@
+# Blender 3.3.1
+# www.blender.org
+o Cube
+v 1.000000 1.000000 1.000000
+v 1.000000 1.000000 -1.000000
+v 1.000000 -2.000000 -1.000000
+v -1.000000 1.000000 1.000000
+v -1.000000 1.000000 -1.000000
+v -1.000000 -2.000000 -1.000000
+s 0
+f 5 2 3 6
+f 5 4 1 2
+f 3 1 4 6
+f 2 1 3
+f 6 4 5

gpudrive-main/assets/ramp_render.obj

@@ -0,0 +1,36 @@
+# Blender 3.3.1
+# www.blender.org
+o Cube
+v 1.000000 1.000000 1.000000
+v 1.000000 1.000000 -1.000000
+v 1.000000 -2.000000 -1.000000
+v -1.000000 1.000000 1.000000
+v -1.000000 1.000000 -1.000000
+v -1.000000 -2.000000 -1.000000
+v 1.000000 1.000000 1.000000
+v -1.000000 1.000000 1.000000
+vn -0.0000 -0.0000 -1.0000
+vn -0.0000 1.0000 -0.0000
+vn -0.0000 -0.5547 0.8321
+vn 1.0000 -0.0000 -0.0000
+vn -1.0000 -0.0000 -0.0000
+vt 0.625000 0.500000
+vt 0.375000 0.500000
+vt 0.375000 0.750000
+vt 0.625000 0.250000
+vt 0.375000 0.250000
+vt 0.125000 0.500000
+vt 0.125000 0.750000
+vt 0.000000 0.000000
+vt 0.000000 0.000000
+s 0
+f 2/2/1 6/7/1 5/6/1
+f 4/4/2 2/2/2 5/5/2
+f 7/8/3 6/7/3 3/3/3
+f 2/2/4 7/8/4 3/3/4
+f 6/7/5 8/9/5 5/6/5
+f 2/2/1 3/3/1 6/7/1
+f 4/4/2 1/1/2 2/2/2
+f 7/8/3 8/9/3 6/7/3
+l 1 7
+l 4 8

gpudrive-main/assets/wall_collision.obj

@@ -0,0 +1,18 @@
+# Blender 3.4.1
+# www.blender.org
+o Cube
+v 0.500000 0.500000 2.500000
+v 0.500000 0.500000 0.000000
+v 0.500000 -0.500000 2.500000
+v 0.500000 -0.500000 0.000000
+v -0.500000 0.500000 2.500000
+v -0.500000 0.500000 0.000000
+v -0.500000 -0.500000 2.500000
+v -0.500000 -0.500000 0.000000
+s 0
+f 1 5 7 3
+f 4 3 7 8
+f 8 7 5 6
+f 6 2 4 8
+f 2 1 3 4
+f 6 5 1 2

gpudrive-main/assets/wall_render.obj

@@ -0,0 +1,44 @@
+# Blender 3.4.1
+# www.blender.org
+o Cube
+v 0.500000 0.500000 2.500000
+v 0.500000 0.500000 0.000000
+v 0.500000 -0.500000 2.500000
+v 0.500000 -0.500000 0.000000
+v -0.500000 0.500000 2.500000
+v -0.500000 0.500000 0.000000
+v -0.500000 -0.500000 2.500000
+v -0.500000 -0.500000 0.000000
+vn -0.0000 -0.0000 1.0000
+vn -0.0000 -1.0000 -0.0000
+vn -1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vn 1.0000 -0.0000 -0.0000
+vn -0.0000 1.0000 -0.0000
+vt 0.625000 0.500000
+vt 0.375000 0.500000
+vt 0.625000 0.750000
+vt 0.375000 0.750000
+vt 0.875000 0.500000
+vt 0.625000 0.250000
+vt 0.125000 0.500000
+vt 0.375000 0.250000
+vt 0.875000 0.750000
+vt 0.625000 1.000000
+vt 0.625000 0.000000
+vt 0.375000 0.000000
+vt 0.375000 1.000000
+vt 0.125000 0.750000
+s 0
+f 5/5/1 3/3/1 1/1/1
+f 3/3/2 8/13/2 4/4/2
+f 7/11/3 6/8/3 8/12/3
+f 2/2/4 8/14/4 6/7/4
+f 1/1/5 4/4/5 2/2/5
+f 5/6/6 2/2/6 6/8/6
+f 5/5/1 7/9/1 3/3/1
+f 3/3/2 7/10/2 8/13/2
+f 7/11/3 5/6/3 6/8/3
+f 2/2/4 4/4/4 8/14/4
+f 1/1/5 3/3/5 4/4/5
+f 5/6/6 1/1/6 2/2/6

gpudrive-main/baselines/imitation_data_generation.py

@@ -0,0 +1,279 @@
+"""Extract expert states and actions from Waymo Open Dataset."""
+import torch
+import numpy as np
+import imageio
+import logging
+import argparse
+
+from pygpudrive.env.config import EnvConfig, RenderConfig, SceneConfig
+from pygpudrive.env.env_torch import GPUDriveTorchEnv
+
+logging.getLogger(__name__)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser("Select the dynamics model that you use")
+    parser.add_argument(
+        "--dynamics-model",
+        "-d",
+        type=str,
+        default="delta_local",
+        choices=["delta_local", "bicycle", "classic"],
+    )
+    args = parser.parse_args()
+    return args
+
+
+def map_to_closest_discrete_value(grid, cont_actions):
+    """
+    Find the nearest value in the action grid for a given expert action.
+    """
+    # Calculate the absolute differences and find the indices of the minimum values
+    abs_diff = torch.abs(grid.unsqueeze(0) - cont_actions.unsqueeze(-1))
+    indx = torch.argmin(abs_diff, dim=-1)
+
+    # Gather the closest values based on the indices
+    closest_values = grid[indx]
+
+    return closest_values, indx
+
+
+def generate_state_action_pairs(
+    env,
+    device,
+    action_space_type="discrete",
+    use_action_indices=False,
+    make_video=False,
+    render_index=[0],
+    save_path="output_video.mp4",
+):
+    """Generate pairs of states and actions from the Waymo Open Dataset.
+
+    Args:
+        env (GPUDriveTorchEnv): Initialized environment class.
+        device (str): Where to run the simulation (cpu or cuda).
+        action_space_type (str): discrete, multi-discrete, continuous
+        use_action_indices (bool): Whether to return action indices instead of action values.
+        make_video (bool): Whether to save a video of the expert trajectory.
+        render_index (int): Index of the world to render (must be <= num_worlds).
+
+    Returns:
+        expert_actions: Expert actions for the controlled agents. An action is a
+            tuple with (acceleration, steering, heading).
+        obs_tensor: Expert observations for the controlled agents.
+    """
+    frames = [[] for _ in range(render_index[1] - render_index[0])]
+
+    logging.info(
+        f"Generating expert actions and observations for {env.num_worlds} worlds \n"
+    )
+
+    # Reset the environment
+    obs = env.reset()
+
+    # Get expert actions for full trajectory in all worlds
+    expert_actions, expert_speeds, expert_positions, expert_yaws = env.get_expert_actions()
+    if action_space_type == "discrete":
+        # Discretize the expert actions: map every value to the closest
+        # value in the action grid.
+        disc_expert_actions = expert_actions.clone()
+        if env.config.dynamics_model == "delta_local":
+            disc_expert_actions[:, :, :, 0], _ = map_to_closest_discrete_value(
+                grid=env.dx, cont_actions=expert_actions[:, :, :, 0]
+            )
+            disc_expert_actions[:, :, :, 1], _ = map_to_closest_discrete_value(
+                grid=env.dy, cont_actions=expert_actions[:, :, :, 1]
+            )
+            disc_expert_actions[:, :, :, 2], _ = map_to_closest_discrete_value(
+                grid=env.dyaw, cont_actions=expert_actions[:, :, :, 2]
+            )
+        else:
+            # Acceleration
+            disc_expert_actions[:, :, :, 0], _ = map_to_closest_discrete_value(
+                grid=env.accel_actions, cont_actions=expert_actions[:, :, :, 0]
+            )
+            # Steering
+            disc_expert_actions[:, :, :, 1], _ = map_to_closest_discrete_value(
+                grid=env.steer_actions, cont_actions=expert_actions[:, :, :, 1]
+            )
+
+        if use_action_indices:  # Map action values to joint action index
+            logging.info("Mapping expert actions to joint action index... \n")
+            expert_action_indices = torch.zeros(
+                expert_actions.shape[0],
+                expert_actions.shape[1],
+                expert_actions.shape[2],
+                1,
+                dtype=torch.int32,
+            ).to(device)
+            for world_idx in range(disc_expert_actions.shape[0]):
+                for agent_idx in range(disc_expert_actions.shape[1]):
+                    for time_idx in range(disc_expert_actions.shape[2]):
+                        action_val_tuple = tuple(
+                            round(x, 3)
+                            for x in disc_expert_actions[
+                                world_idx, agent_idx, time_idx, :
+                            ].tolist()
+                        )
+                        if not env.config.dynamics_model == "delta_local":
+                            action_val_tuple = (
+                                action_val_tuple[0],
+                                action_val_tuple[1],
+                                0.0,
+                            )
+
+                        action_idx = env.values_to_action_key.get(
+                            action_val_tuple
+                        )
+                        expert_action_indices[
+                            world_idx, agent_idx, time_idx
+                        ] = action_idx
+
+            expert_actions = expert_action_indices
+        else:
+            # Map action values to joint action index
+            expert_actions = disc_expert_actions
+    elif action_space_type == "multi_discrete":
+        """will be update"""
+        pass
+    else:
+        logging.info("Using continuous expert actions... \n")
+
+    # Storage
+    expert_observations_lst = []
+    expert_actions_lst = []
+    expert_next_obs_lst = []
+    expert_dones_lst = []
+
+    # Initialize dead agent mask
+
+    dead_agent_mask = ~env.cont_agent_mask.clone()
+    alive_agent_mask = env.cont_agent_mask.clone()
+    for time_step in range(env.episode_len):
+
+        # Step the environment with inferred expert actions
+        env.step_dynamics(expert_actions[:, :, time_step, :])
+
+        next_obs = env.get_obs()
+
+        dones = env.get_dones()
+        infos = env.get_infos()
+
+        # Unpack and store (obs, action, next_obs, dones) pairs for controlled agents
+        expert_observations_lst.append(obs[~dead_agent_mask, :])
+        expert_actions_lst.append(
+            expert_actions[~dead_agent_mask][:, time_step, :]
+        )
+
+        expert_next_obs_lst.append(next_obs[~dead_agent_mask, :])
+        expert_dones_lst.append(dones[~dead_agent_mask])
+
+        # Update
+        obs = next_obs
+        dead_agent_mask = torch.logical_or(dead_agent_mask, dones)
+
+        # Render
+        if make_video:
+            for render in range(render_index[0], render_index[1]):
+                frame = env.render(world_render_idx=render)
+                frames[render].append(frame)
+        if (dead_agent_mask == True).all():
+            break
+
+    is_collision = infos[:, :, :3].sum(dim=-1)
+    is_goal = infos[:, :, 3]
+    collision_mask = is_collision != 0
+    goal_mask = is_goal != 0
+    valid_collision_mask = collision_mask & alive_agent_mask
+    valid_goal_mask = goal_mask & alive_agent_mask
+    collision_rate = (
+        valid_collision_mask.sum().float() / alive_agent_mask.sum().float()
+    )
+    goal_rate = valid_goal_mask.sum().float() / alive_agent_mask.sum().float()
+
+    print(f"Collision {collision_rate} Goal {goal_rate}")
+
+    if make_video:
+        for render in range(render_index[0], render_index[1]):
+            imageio.mimwrite(
+                f"{save_path}_world_{render}.mp4",
+                np.array(frames[render]),
+                fps=30,
+            )
+
+    flat_expert_obs = torch.cat(expert_observations_lst, dim=0)
+    flat_expert_actions = torch.cat(expert_actions_lst, dim=0)
+    flat_next_expert_obs = torch.cat(expert_next_obs_lst, dim=0)
+    flat_expert_dones = torch.cat(expert_dones_lst, dim=0)
+
+    return (
+        flat_expert_obs,
+        flat_expert_actions,
+        flat_next_expert_obs,
+        flat_expert_dones,
+        goal_rate,
+        collision_rate,
+    )
+
+
+if __name__ == "__main__":
+    import argparse
+
+    args = parse_args()
+    torch.set_printoptions(precision=3, sci_mode=False)
+    NUM_WORLDS = 10
+    MAX_NUM_OBJECTS = 128
+
+    # Initialize lists to store results
+    num_actions = []
+    goal_rates = []
+    collision_rates = []
+
+    # Set the environment and render configurations
+    # Action space (joint discrete)
+
+    render_config = RenderConfig(draw_obj_idx=True)
+    scene_config = SceneConfig(
+        "/data/formatted_json_v2_no_tl_train/", NUM_WORLDS
+    )
+    env_config = EnvConfig(
+        dynamics_model=args.dynamics_model,
+        steer_actions=torch.round(torch.linspace(-0.3, 0.3, 7), decimals=3),
+        accel_actions=torch.round(torch.linspace(-6.0, 6.0, 7), decimals=3),
+        dx=torch.round(torch.linspace(-3.0, 3.0, 100), decimals=3),
+        dy=torch.round(torch.linspace(-3.0, 3.0, 100), decimals=3),
+        dyaw=torch.round(torch.linspace(-1.0, 1.0, 300), decimals=3),
+    )
+
+    env = GPUDriveTorchEnv(
+        config=env_config,
+        scene_config=scene_config,
+        max_cont_agents=MAX_NUM_OBJECTS,  # Number of agents to control
+        device="cpu",
+        render_config=render_config,
+        action_type="continuous",
+    )
+    # Generate expert actions and observations
+    (
+        expert_obs,
+        expert_actions,
+        next_expert_obs,
+        expert_dones,
+        goal_rate,
+        collision_rate,
+    ) = generate_state_action_pairs(
+        env=env,
+        device="cpu",
+        action_space_type="continuous",  # Discretize the expert actions
+        use_action_indices=True,  # Map action values to joint action index
+        make_video=True,  # Record the trajectories as sanity check
+        render_index=[0, 1],  # start_idx, end_idx
+        save_path="use_discr_actions_fix",
+    )
+    env.close()
+    del env
+    del env_config
+
+    # Uncommment to save the expert actions and observations
+    # torch.save(expert_actions, "expert_actions.pt")
+    # torch.save(expert_obs, "expert_obs.pt")

gpudrive-main/baselines/ppo/README.md

@@ -0,0 +1,106 @@
+# Using IPPO in GPUDrive
+
+## PufferLib implementation
+
+### Dependencies
+
+This implementation is compatible with the `gpudrive` branch of [PufferLib](https://github.com/PufferAI/PufferLib/tree/gpudrive/pufferlib/environments/gpudrive). To install, run:
+
+```
+pip install git+https://github.com/PufferAI/PufferLib.git@gpudrive
+```
+
+### Example
+
+- Launch a run:
+
+```bash
+python baselines/ippo/ippo_pufferlib.py
+```
+
+- Configs are in `baselines/ippo/config/ippo_ff_puffer.yaml`
+- A small feedforward network is implemented in `integrations/rl/puffer/utils.py`
+
+## Stable baselines 3 implementation
+
+### Example
+
+- Launch a run:
+
+```
+python baselines/ippo/ippo_sb3.py
+```
+
+- Configurations are found in `baselines/ippo/config/ippo_ff_sb3.yaml`
+
+### Details
+
+#### Resampling the data
+
+The configuration for resampling traffic scenarios includes:
+
+- **`resample_scenarios`**: A boolean that enables or disables traffic scenario resampling when set to `True`.
+- **`resample_criterion`**: Set to `"global_step"`, indicating resampling occurs based on the global step count.
+- **`resample_freq`**: Specifies resampling frequency at `50,000` steps, recommended to align with `num_worlds * n_steps`.
+- **`resample_mode`**: Set to `"random"` for random selection of new scenarios.
+
+```
+# RESAMPLE TRAFFIC SCENARIOS
+resample_scenarios: bool = True
+resample_criterion: str = "global_step" # Options: "global_step"
+resample_freq: int = 100_000 # Resample every k steps (recommended to be a multiple of num_worlds * n_steps)
+resample_mode: str = "random" # Options: "random"
+```
+
+#### Implemented networks
+
+- Classic Observations
+
+For classic observations (e.g., `ego_state`), there is support for a permutation equivariant network (recommended). In `baselines/ippo/config.py`, set the following:
+
+```python
+# NETWORK
+mlp_class = LateFusionNet
+policy = LateFusionPolicy
+```
+
+The default settings for classic observations are:
+
+```python
+ego_state: bool = True  # Use ego vehicle state
+road_map_obs: bool = True  # Use road graph data
+partner_obs: bool = True  # Include partner vehicle information
+norm_obs: bool = True  # Normalize observations
+```
+
+- LiDAR Observations
+
+For only LiDAR-based observations, set the following options:
+
+```python
+ego_state: bool = False  # Use ego vehicle state
+road_map_obs: bool = False  # Use road graph data
+partner_obs: bool = False  # Include partner vehicle information
+norm_obs: bool = False  # Normalize observations
+disable_classic_obs: bool = True  # Disable classic observations for faster sim
+lidar_obs: bool = True  # Use LiDAR in observations
+```
+
+You can also **mix** classic and LiDAR observations by setting:
+
+```python
+ego_state: bool = True  # Include ego vehicle state in observations
+road_map_obs: bool = True  # Include road graph in observations
+partner_obs: bool = True  # Include partner vehicle info in observations
+norm_obs: bool = True  # Normalize observations
+disable_classic_obs: bool = False  # Keep classic observations
+lidar_obs: bool = True  # Add LiDAR to observations
+```
+
+In both cases, you can use a feedforward network from `networks/basic_ffn.py`:
+
+```python
+# NETWORK
+mlp_class = FFN
+policy = FeedForwardPolicy
+```