update readme and replay script

README.md

@@ -7,4 +7,64 @@ tags:
 - imitation-learning
 size_categories:
 - 10K<n<100K
----
+---
+
+# UniPhys Dataset: Offline Dataset for Physics-based Character Control
+
+This dataset is part of the [UniPhys](https://wuyan01.github.io/uniphys-project/), enabling large-scale training of diffusion policies for physics-based humanoid control using SMPL-like characters. The state-action pairs are generated by the [PULSE](https://www.zhengyiluo.com/PULSE-Site/) motion tracking policy.
+
+## Dataset Overview
+* `amass_state-action-pairs`: state-action pairs for motion sequences from AMASS dataset (excluding infeasible motions)
+* `babel_state-action-text-pairs`: Packaged AMASS motions with [BABEL](https://babel.is.tue.mpg.de/) frame-level text annotations.
+
+### AMASS state-action pairs
+
+#### Data Structure
+For each sequence, the dataset contains:
+| Field | Shape | Description |
+|-------|-------|-------------|
+| `body_pos` | `[T, 24, 3]` | Joint positions in global space |
+| `dof_state` | `[T, 69, 2]` | Joint rotations (dim 0) and velocities (dim 1)<br>*69 = 23 joints × 3 DoF each* |
+| `root_state` | `[T, 13]` | Contains:<br>- Position (0:3)<br>- Quaternion (3:7)<br>- Linear velocity (7:10)<br>- Angular velocity (10:13) |
+| `action` | `[T, 69]` | Joint angle targets (23 joints × 3 DoF) |
+| `pulse_z` | `[T, 32]` | Latent action space from PULSE policy |
+| `is_succ` | `bool` | Tracking success flag (True/False) |
+| `fps` | `int` | Frame rate (30 FPS) |
+
+#### Visualization
+To replay the sequence:
+```
+python replay_amass_state_action_pairs.py --load_motion_path amass_state-action-pairs/$YOUR_FILE_PATH
+```
+
+### BABEL state-action-text pairs
+This is the training dataset used in [UniPhys](https://wuyan01.github.io/uniphys-project/).
+
+#### Visualization
+To replay the packaged offline BABEL dataset along with frame-level text annotation:
+```
+python replay_babel_state_action_text_pairs.py --load_motion_path babel_state-action-text-pairs/babel_train.pkl
+```
+
+## Citation
+If using this dataset useful, please cite:
+```
+@inproceedings{wu2025uniphys,
+  title={UniPhys: Unified Planner and Controller with Diffusion for Flexible Physics-Based Character Control},
+  author={Wu, Yan and Karunratanakul, Korrawe and Luo, Zhengyi and Tang, Siyu},
+  booktitle = {Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)},
+  year={2025}
+}
+
+```
+
+```
+@inproceedings{
+luo2024universal,
+title={Universal Humanoid Motion Representations for Physics-Based Control},
+author={Zhengyi Luo and Jinkun Cao and Josh Merel and Alexander Winkler and Jing Huang and Kris M. Kitani and Weipeng Xu},
+booktitle={The Twelfth International Conference on Learning Representations},
+year={2024},
+url={https://openreview.net/forum?id=OrOd8PxOO2}
+}
+```

replay.py → replay_amass_state_action_pairs.py

@@ -92,7 +92,7 @@ if viewer is None:
 # ---------------------------------------------------------
 # Load asset
 # ---------------------------------------------------------
-asset_root = "./assets"
+asset_root = "./assets/"
 asset_file = asset_descriptors[args.asset_id].file_name
 
 asset_options = gymapi.AssetOptions()
@@ -158,8 +158,7 @@ cam_target = gymapi.Vec3(0, 0, 1)
 gym.viewer_camera_look_at(viewer, None, cam_pos, cam_target)
 
 time_step = 0
-fps = 60.0
-dt = 1.0 / fps
+fps = 30.0
 
 print("Starting playback...")
 
@@ -180,5 +179,10 @@ while not gym.query_viewer_has_closed(viewer):
 
     time_step += 1
 
+    print("\r" + " " * 200, end="")
+    print(f"\rTime step: {motion_time} / {motion_length}", end="")
+
+    import time; time.sleep(1.0 / fps)
+
 gym.destroy_viewer(viewer)
 gym.destroy_sim(sim)

replay_babel_state_action_text_pairs.py

@@ -0,0 +1,202 @@
+import os
+import joblib
+import numpy as np
+from isaacgym import gymapi, gymutil, gymtorch
+import torch
+
+# ---------------------------------------------------------
+# Asset description class
+# ---------------------------------------------------------
+class AssetDesc:
+    def __init__(self, file_name, flip_visual_attachments=False):
+        self.file_name = file_name
+        self.flip_visual_attachments = flip_visual_attachments
+
+# ---------------------------------------------------------
+# Define assets
+# ---------------------------------------------------------
+asset_descriptors = [AssetDesc("smpl_humanoid.xml", False)]
+
+# ---------------------------------------------------------
+# Parse arguments
+# ---------------------------------------------------------
+args = gymutil.parse_arguments(
+    description="Visualize motion sequence in Isaac Gym",
+    custom_parameters=[
+        {
+            "name": "--asset_id",
+            "type": int,
+            "default": 0,
+            "help": f"Asset id (0 - {len(asset_descriptors) - 1})",
+        },
+        {
+            "name": "--show_axis",
+            "action": "store_true",
+            "help": "Visualize DOF axis",
+        },
+        {
+            "name": "--load_motion_path",
+            "type": str,
+            "default": "./CMU/01/01_01_poses.pkl",
+            "help": "Path to motion pickle file",
+        },
+    ],
+)
+
+if not (0 <= args.asset_id < len(asset_descriptors)):
+    print(f"*** Invalid asset_id specified. Valid range is 0 to {len(asset_descriptors) - 1}")
+    quit()
+
+
+# ---------------------------------------------------------
+# Initialize simulator
+# ---------------------------------------------------------
+gym = gymapi.acquire_gym()
+
+sim_params = gymapi.SimParams()
+sim_params.dt = 1.0 / 60.0
+sim_params.up_axis = gymapi.UP_AXIS_Z
+sim_params.gravity = gymapi.Vec3(0.0, 0.0, -9.81)
+
+if args.physics_engine == gymapi.SIM_PHYSX:
+    sim_params.physx.solver_type = 1
+    sim_params.physx.num_position_iterations = 6
+    sim_params.physx.num_threads = args.num_threads
+    sim_params.physx.use_gpu = args.use_gpu
+    sim_params.use_gpu_pipeline = args.use_gpu_pipeline
+
+if not args.use_gpu_pipeline:
+    print("WARNING: Forcing CPU pipeline.")
+
+sim = gym.create_sim(args.compute_device_id, args.graphics_device_id, args.physics_engine, sim_params)
+if sim is None:
+    print("*** Failed to create sim")
+    quit()
+
+
+# ---------------------------------------------------------
+# Ground and viewer setup
+# ---------------------------------------------------------
+plane_params = gymapi.PlaneParams()
+plane_params.normal = gymapi.Vec3(0.0, 0.0, 1.0)
+gym.add_ground(sim, plane_params)
+
+viewer = gym.create_viewer(sim, gymapi.CameraProperties())
+if viewer is None:
+    print("*** Failed to create viewer")
+    quit()
+
+
+# ---------------------------------------------------------
+# Load asset
+# ---------------------------------------------------------
+asset_root = "./assets/"
+asset_file = asset_descriptors[args.asset_id].file_name
+
+asset_options = gymapi.AssetOptions()
+asset_options.use_mesh_materials = True
+
+print(f"Loading asset '{asset_file}' from '{asset_root}'")
+asset = gym.load_asset(sim, asset_root, asset_file, asset_options)
+
+
+# ---------------------------------------------------------
+# Create environment
+# ---------------------------------------------------------
+num_envs = 1
+num_per_row = 1
+spacing = 5.0
+
+env_lower = gymapi.Vec3(-spacing, -spacing, 0)
+env_upper = gymapi.Vec3(spacing, spacing, spacing)
+
+envs, actor_handles = [], []
+num_dofs = gym.get_asset_dof_count(asset)
+
+print(f"Creating {num_envs} environment(s)")
+for i in range(num_envs):
+    env = gym.create_env(sim, env_lower, env_upper, num_per_row)
+    envs.append(env)
+
+    pose = gymapi.Transform()
+    actor_handle = gym.create_actor(env, asset, pose, "actor", i, 1)
+    actor_handles.append(actor_handle)
+
+    dof_states = np.zeros(num_dofs, dtype=gymapi.DofState.dtype)
+    gym.set_actor_dof_states(env, actor_handle, dof_states, gymapi.STATE_ALL)
+
+gym.prepare_sim(sim)
+
+# ---------------------------------------------------------
+# Load motion sequence
+# ---------------------------------------------------------
+load_motion_path = args.load_motion_path
+assert os.path.exists(load_motion_path), f"Motion file not found: {load_motion_path}"
+
+motion = joblib.load(load_motion_path)
+batch_size = len(motion["root_state_all"])
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+print(f"Loaded {batch_size} motion from {load_motion_path}")
+
+
+# ---------------------------------------------------------
+# Simulation loop
+# ---------------------------------------------------------
+rigidbody_state = gymtorch.wrap_tensor(gym.acquire_rigid_body_state_tensor(sim)).reshape(num_envs, -1, 13)
+actor_root_state = gymtorch.wrap_tensor(gym.acquire_actor_root_state_tensor(sim))
+
+cam_pos = gymapi.Vec3(0, -5.0, 3)
+cam_target = gymapi.Vec3(0, 0, 1)
+gym.viewer_camera_look_at(viewer, None, cam_pos, cam_target)
+
+time_step = 0
+fps = 30.0
+
+print("Starting playback...")
+
+while not gym.query_viewer_has_closed(viewer):
+
+    for b in range(batch_size):
+
+        time_step = 0
+        motion_length = len(motion["root_state_all"][b])
+        motion_name = motion["motion_file"][b].split(".")[0]
+        is_succ = motion["is_succ_all"][b]
+        root_states = torch.from_numpy(motion["root_state_all"][b]).to(device)
+        dof_states = torch.from_numpy(motion["dof_state_all"][b]).to(device)
+
+        # preprocess the text annotations
+        raw_text_anns = motion["frame_labels_all"][b]
+        for ann in raw_text_anns:
+            ann['start_f'] = int(ann['start_t'] * fps)
+            ann['end_f'] = int(ann['end_t'] * fps)
+
+        frame_labels = ["none"] * motion_length
+        for ann in raw_text_anns:
+            for f in range(ann['start_f'], min(ann['end_f'], motion_length)):
+                frame_labels[f] = ann['proc_label']
+
+        for t in range(motion_length):
+            motion_time = time_step % motion_length
+
+            if args.show_axis:
+                gym.clear_lines(viewer)
+
+            gym.set_actor_root_state_tensor(sim, gymtorch.unwrap_tensor(root_states[motion_time:motion_time + 1]))
+            gym.set_dof_state_tensor(sim, gymtorch.unwrap_tensor(dof_states[motion_time]))
+
+            gym.simulate(sim)
+            gym.fetch_results(sim, True)
+            gym.step_graphics(sim)
+            gym.draw_viewer(viewer, sim, True)
+            gym.sync_frame_time(sim)
+
+            time_step += 1
+            print("\r" + " " * 200, end="")
+            print(f"\rMotion {b + 1}/{batch_size}, Name: {motion_name}, is_succ: {is_succ}, frame {t + 1}/{motion_length}, text: {frame_labels[t]}", end="")
+
+            import time; time.sleep(1.0 / fps)
+
+gym.destroy_viewer(viewer)
+gym.destroy_sim(sim)