Add files using upload-large-folder tool

real_inference/README.md

@@ -0,0 +1,64 @@
+# Aloha 2 号机真机推理：模型与复现材料
+
+这个目录整理了服务器上训练得到的 ACT、DP 和 π0.5 LoRA 模型、配套统计量、模型源码快照、依赖版本记录和离线输入样本，供实验室工控机上的开发者或 Codex 接入当地已有的 ROS 代码。本目录**不是已经完成真机验证的 ROS 部署程序**，不会自动连接或控制机械臂。
+
+## 目录与文件
+
+| 路径 | 作用 |
+| --- | --- |
+| `models/act/policy_best.ckpt` | ACT 的最佳验证 checkpoint，预测 50×14 |
+| `models/act/dataset_stats.pkl` | ACT 的训练集 state/action 均值和标准差；需与 checkpoint 配套 |
+| `models/dp/10.ckpt` | DP 最后一轮 checkpoint（包括 EMA、模型、归一化及训练状态），预测 6×14 可执行动作 |
+| `models/pi05/29999/` | π0.5 LoRA 的完整 Orbax checkpoint。`params/` 是参数，`assets/aloha_garment/norm_stats.json` 是推理归一化统计，`train_state/` 与元数据用于保留原始 checkpoint 结构 |
+| `models/shared/openpi/big_vision/paligemma_tokenizer.model` | π0.5 使用的 tokenizer，便于离线加载 |
+| `models/shared/torch/hub/checkpoints/resnet18-f37072fd.pth` | 当前 ACT 初始化时可能访问的 torchvision 缓存；最终权重仍由 ACT checkpoint 覆盖 |
+| `source/XPolicyLab/` | 实际使用的 ACT `detr/`、DP `diffusion_policy/` 和 OpenPI `src/`、客户端包、锁文件及许可证的快照，包含服务器未提交的代码 |
+| `source/xpolicylab_local_changes.patch` | 服务器 XPolicyLab 相对基线的相关已跟踪文件差异，供核对；未跟踪的源码已直接包含在快照中 |
+| `reference/` | 仿真中使用的策略 adapter、通信协议和服务脚本参考；原始 adapter 仍含服务器绝对路径，不能直接作为工控机启动脚本 |
+| `environments/` | 服务器 Python 包版本清单；用于比对，不是可直接复制的虚拟环境或经过工控机验证的锁定安装方案 |
+| `fixtures/0041_episode0_frame100.npz` | 一帧真实录制的三路 RGB、14 维 qpos 和下一帧动作，供不连接机器人时检查 |
+| `check_fixture.py` | 使用上述本地权重和快照进行模型单次推理的参考检查，不发送 ROS 指令 |
+| `manifest.sha256`、`verify_files.py` | 文件 SHA-256 清单和校验工具 |
+
+服务器基线为 XPolicyLab `1e815ad750ba27407ec2e1a97cb4674a43d0734d`；因为本次训练有本地改动，不能仅依赖该 Git 版本复现，应该以本目录快照与补丁为准。源码的上游许可证随快照保留。
+
+## 输入输出约定
+
+- 相机：`cam_high`、`cam_left_wrist`、`cam_right_wrist`，依次对应 `camera_f`、`camera_l`、`camera_r`。模型适配器输入 RGB uint8；ACT 使用 640×480，DP 适配器缩放到 320×240，π0.5 使用 OpenPI 自身的图像变换。
+- 状态和动作：14 维，按 `[左臂 6 关节, 左夹爪, 右臂 6 关节, 右夹爪]` 排列；使用数据采集时的绝对关节位置和夹爪开度，不是末端轨迹。采集数据 `action[t]` 是配对后的下一时刻从臂状态。工控机接入时必须核对真实驱动的顺序、量纲和夹爪数值语义。
+- 动作时间间隔为 0.04 秒。ACT 无 temporal aggregation 的参考方式为预测 50、执行 50；DP 观测最近 3 帧、预测 horizon 8、执行 6；π0.5 预测 50、执行 5。DP 执行多步期间也需每个控制步采样并更新观测历史。以上是已实现的仿真评测设置，真机效果尚未验证。
+- π0.5 任务指令：`Fold the garment.`；本次配置使用 `adapt_to_pi=False` 和 `use_delta_joint_actions=False`，不要套用其他 Aloha 硬件的关节翻转、夹爪变换或 delta action。
+
+## 工控机接入边界
+
+设备手册说明 2 号机推理模式使用 `/puppet/pos_joint_cmd_left`、`/puppet/pos_joint_cmd_right`，状态使用 `/puppet/joint_left`、`/puppet/joint_right`；三路彩色相机为 `/camera_f/color/image_raw`、`/camera_l/color/image_raw`、`/camera_r/color/image_raw`。最终话题、消息字段、频率、关节顺序和单位应以工控机实际驱动核实。
+
+手册要求从遥操作模式切换到推理模式时，先给机械臂断电，再启动推理模式，否则从臂可能失能掉落。ROS 客户端、动作限幅、紧急停止、接入验证及实机操作由工控机侧基于本机现有代码实现和检查。本目录里的参考 WebSocket 服务协议与手册 OpenPI 客户端协议不同，不应直接假定互通。
+
+## 校验与离线模型检查
+
+传输后在本目录运行：
+
+```bash
+python verify_files.py
+```
+
+工具会读取 `manifest.sha256` 并校验已列文件。计算权重哈希需要读取约 8 GiB 数据；不会联网或运行机器人。
+
+在分别安装了对应依赖的环境中，可以对真实样本执行模型检查：
+
+```bash
+CUDA_VISIBLE_DEVICES=0 python check_fixture.py act
+CUDA_VISIBLE_DEVICES=0 python check_fixture.py dp
+CUDA_VISIBLE_DEVICES=0 python check_fixture.py pi05
+```
+
+ACT、DP 的参考 adapter 当前使用 CUDA；π0.5 可用 `JAX_PLATFORMS=cpu` 做较慢的 CPU 检查。DP 原服务器运行时把 `policy_training/dp_compat` 放在 `PYTHONPATH` 最前面（有效 numpy 1.23.5、OpenCV 4.10.0）；本目录没有复制依赖机器 ABI 的兼容目录，工控机需安装兼容版本。原始源码中部分训练用途的路径仍指向服务器，`check_fixture.py` 只在运行时覆盖参考 adapter 所需权重和代码路径。三种策略均可能有随机性，脚本只核验输出维度和有限性，不以单帧预测误差衡量模型优劣。
+
+`act_pip_freeze.txt`、`dp_pip_freeze.txt` 是服务器环境快照，含本地 editable 依赖，**不应直接当作可移植 requirements 安装**；π0.5 的完整环境版本见 `pi05_packages.txt` 和 OpenPI 的 `uv.lock`。应按工控机操作系统、驱动、CUDA 及 ROS Python 版本重新配置或验证模型环境。模型服务与 ROS 客户端可使用不同 Python 环境。
+
+服务器离线检查记录：ACT 与 DP 在各自 GPU 环境、π0.5 在 CPU 环境，均以本目录的源码快照、权重和 0041 第 100 帧样本完成单帧推理；输出分别为 `(50,14)`、`(6,14)`、`(50,14)`，全部为有限值。DP 检查仍使用服务器已有的 `dp_compat`；这不代表工控机依赖或 ROS 接口已完成验证。
+
+## 传输
+
+整个目录约 8.2 GiB，可传到 Hugging Face 仓库或用其他方式复制。请保持 `models/pi05/29999/` 的目录结构，传输后运行校验。当前上层仓库的 `.gitignore` 默认忽略新的顶层目录；普通 GitHub push 不会自动包含本目录，且权重不适合直接放入普通 Git。这里尚未将任何文件上传。

real_inference/environments/act_pip_freeze.txt

@@ -0,0 +1,89 @@
+absl-py==2.5.1
+annotated-types==0.8.0
+asttokens==3.0.2
+attrs==26.1.0
+catkin-pkg==1.1.1
+certifi==2026.10.23
+charset-normalizer==3.5.2
+contourpy==1.3.2
+cycler==0.12.1
+decorator==5.3.1
+-e git+https://github.com/XPolicyLab/XPolicyLab.git@1e815ad750ba27407ec2e1a97cb4674a43d0734d#egg=detr&subdirectory=../../XPolicyLab/policy/ACT/detr
+distro==1.9.0
+dm-control==1.0.14
+dm-env==1.6
+dm-tree==0.1.10
+docutils==0.23
+einops==0.8.2
+exceptiongroup==1.3.1
+executing==2.3.0
+filelock==4.1.0
+fonttools==4.65.0
+fsspec==2026.9.0
+glfw==2.11.0
+h5py==3.16.0
+idna==3.20
+ipython==8.39.0
+jedi==0.20.1
+Jinja2==3.1.6
+kiwisolver==1.5.1
+labmaze==1.0.6
+lxml==6.1.3
+MarkupSafe==3.0.4
+matplotlib==3.10.9
+matplotlib-inline==0.2.2
+mpmath==1.3.0
+msgpack==1.2.4
+msgpack-numpy==0.4.8
+mujoco==2.3.7
+networkx==3.4.2
+numpy==2.2.6
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu12==9.1.0.70
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-nccl-cu12==2.20.5
+nvidia-nvjitlink-cu12==12.9.86
+nvidia-nvtx-cu12==12.1.105
+opencv-python==5.0.0.93
+opencv-python-headless==5.0.0.93
+packaging==26.3
+parso==0.8.7
+pexpect==4.9.0
+pillow==12.3.0
+prompt_toolkit==3.0.53
+protobuf==7.36.2
+ptyprocess==0.7.0
+pure_eval==0.2.4
+pydantic==2.14.3
+pydantic_core==2.50.4
+Pygments==2.21.0
+PyOpenGL==3.1.10
+pyparsing==3.3.3
+pyquaternion==0.9.9
+python-dateutil==3.0.0
+PyYAML==6.0.3
+requests==2.34.2
+rospkg==1.6.3
+scipy==1.15.3
+six==1.17.0
+stack-data==0.6.3
+sympy==1.14.0
+torch==2.4.1
+torchvision==0.19.1
+tqdm==4.70.1
+traitlets==5.16.1
+triton==3.0.0
+typing-inspection==0.4.5
+typing_extensions==4.16.0
+tzdata==2026.6
+urllib3==2.8.0
+wcwidth==0.9.4
+websockets==16.1.1
+wrapt==2.5.2
+-e git+https://github.com/XPolicyLab/XPolicyLab.git@1e815ad750ba27407ec2e1a97cb4674a43d0734d#egg=xpolicylab&subdirectory=../../XPolicyLab

real_inference/environments/dp_pip_freeze.txt

@@ -0,0 +1,136 @@
+absl-py==2.5.1
+annotated-types==0.8.0
+antlr4-python3-runtime==4.9.3
+anyio==4.16.0
+asciitree==1.0.0
+asttokens==3.0.2
+attrs==26.1.0
+av==17.1.0
+blessed==1.52.0
+certifi==2026.10.23
+charset-normalizer==3.5.2
+click==8.5.1
+contourpy==1.3.2
+cwevals==0.0.1b1
+cycler==0.12.1
+decorator==4.4.2
+diffusers==0.11.1
+-e git+https://github.com/XPolicyLab/XPolicyLab.git@1e815ad750ba27407ec2e1a97cb4674a43d0734d#egg=diffusion_policy&subdirectory=../../XPolicyLab/policy/DP
+dill==0.3.5.1
+distro==1.9.0
+dm-env==1.6
+dm-tree==0.1.10
+dm_control==1.0.50
+einops==0.4.1
+etils==1.13.0
+exceptiongroup==1.3.1
+executing==2.3.0
+fasteners==0.20
+filelock==4.1.0
+fonttools==4.65.0
+fsspec==2026.9.0
+glfw==2.11.0
+googleapis-common-protos==1.76.0
+gpustat==1.1.1
+h11==0.16.0
+h5py==3.16.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.25.2
+hydra-core==1.2.0
+idna==3.20
+ImageIO==2.38.0
+imageio-ffmpeg==0.8.1
+importlib_metadata==9.0.1
+importlib_resources==7.1.0
+ipdb==0.13.13
+ipython==8.39.0
+jedi==0.20.1
+Jinja2==3.1.6
+jinxed==2.1.0
+kiwisolver==1.5.1
+labmaze==1.0.6
+llvmlite==0.39.1
+lxml==6.1.3
+MarkupSafe==3.0.4
+matplotlib==3.10.9
+matplotlib-inline==0.2.2
+moviepy==1.0.3
+mpmath==1.3.0
+msgpack==1.2.4
+msgpack-numpy==0.4.8
+mujoco==3.17.0
+networkx==3.4.2
+numba==0.56.4
+numcodecs==0.13.1
+numpy==2.2.6
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu12==9.1.0.70
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-ml-py==13.615.71
+nvidia-nccl-cu12==2.20.5
+nvidia-nvjitlink-cu12==12.9.86
+nvidia-nvtx-cu12==12.1.105
+omegaconf==2.4.0
+opencv-python==4.11.0.86
+opencv-python-headless==5.0.0.93
+opentelemetry-api==1.45.2
+opentelemetry-exporter-http-transport==0.66b2
+opentelemetry-exporter-otlp-common==0.66b2
+opentelemetry-exporter-otlp-proto-common==1.45.2
+opentelemetry-exporter-otlp-proto-http==1.45.2
+opentelemetry-proto==1.45.2
+opentelemetry-sdk==1.45.2
+opentelemetry-semantic-conventions==0.66b2
+packaging==26.3
+pandas==2.3.3
+parso==0.8.7
+pexpect==4.9.0
+pillow==12.3.0
+platformdirs==4.12.4
+proglog==0.1.12
+prompt_toolkit==3.0.53
+protobuf==7.36.2
+psutil==7.2.2
+ptyprocess==0.7.0
+pure_eval==0.2.4
+pydantic==2.14.3
+pydantic_core==2.50.4
+Pygments==2.21.0
+PyOpenGL==3.1.10
+pyparsing==3.3.3
+python-dateutil==3.0.0
+pytz==2026.6
+PyYAML==6.0.3
+regex==2026.9.29
+requests==2.34.2
+scipy==1.15.3
+six==1.17.0
+sniffio==1.3.1
+stack-data==0.6.3
+sympy==1.14.0
+termcolor==3.3.0
+tomli==2.5.0
+torch==2.4.1
+torchvision==0.19.1
+tqdm==4.70.1
+traitlets==5.16.1
+triton==3.0.0
+typing-inspection==0.4.5
+typing_extensions==4.16.0
+tzdata==2026.6
+urllib3==2.8.0
+wandb==0.31.0
+wcwidth==0.9.4
+websockets==16.1.1
+wrapt==2.5.2
+-e git+https://github.com/XPolicyLab/XPolicyLab.git@1e815ad750ba27407ec2e1a97cb4674a43d0734d#egg=xpolicylab&subdirectory=../../XPolicyLab
+xxhash==4.0.2
+zarr==2.12.0
+zipp==4.1.2

real_inference/environments/pi05_packages.txt

@@ -0,0 +1,225 @@
+# Python 3.11.15 (main, Aug  7 2026, 02:25:55) [Clang 22.1.3 ]
+absl-py==2.3.0
+accelerate==1.13.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.4
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.13.0
+asttokens==3.0.0
+attrs==25.3.0
+augmax==0.4.1
+av==15.1.0
+beartype==0.19.0
+cachetools==5.5.2
+certifi==2025.4.26
+cfgv==3.4.0
+charset-normalizer==3.4.2
+chex==0.1.89
+click==8.2.1
+cloudpickle==3.1.1
+cmake==4.0.2
+comm==0.2.2
+contourpy==1.3.2
+cuda-bindings==12.9.4
+cuda-pathfinder==1.5.5
+cycler==0.12.1
+datasets==4.8.5
+debugpy==1.8.14
+decorator==5.2.1
+deepdiff==8.5.0
+diffusers==0.33.1
+dill==0.3.8
+distlib==0.3.9
+dm-tree==0.1.9
+docstring_parser==0.16
+draccus==0.10.0
+einops==0.8.1
+equinox==0.12.2
+etils==1.12.2
+evdev==1.9.2
+executing==2.2.0
+Farama-Notifications==0.0.4
+filelock==3.18.0
+flatbuffers==25.2.10
+flax==0.10.2
+fonttools==4.58.1
+frozenlist==1.6.0
+fsspec==2025.3.0
+gcsfs==2025.3.0
+gitdb==4.0.12
+GitPython==3.1.44
+google-api-core==2.24.2
+google-auth==2.40.2
+google-auth-oauthlib==1.2.2
+google-cloud-core==2.4.3
+google-cloud-storage==3.1.0
+google-crc32c==1.7.1
+google-resumable-media==2.7.2
+googleapis-common-protos==1.70.0
+gymnasium==1.3.0
+h11==0.16.0
+h5py==3.16.0
+hf-xet==1.5.0
+hf_transfer==0.1.9
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.35.3
+humanize==4.12.3
+identify==2.6.12
+idna==3.10
+imageio==2.37.0
+imageio-ffmpeg==0.6.0
+importlib_metadata==8.7.0
+importlib_resources==6.5.2
+iniconfig==2.1.0
+inquirerpy==0.3.4
+ipykernel==6.29.5
+ipython==9.2.0
+ipython_pygments_lexers==1.1.1
+ipywidgets==8.1.7
+jax==0.5.3
+jax-cuda12-pjrt==0.5.3
+jax-cuda12-plugin==0.5.3
+jaxlib==0.5.3
+jaxtyping==0.2.36
+jedi==0.19.2
+Jinja2==3.1.6
+jsonlines==4.0.0
+jupyter_client==8.6.3
+jupyter_core==5.8.1
+jupyterlab_widgets==3.0.15
+kiwisolver==1.4.8
+lerobot==0.4.4
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+matplotlib==3.10.3
+matplotlib-inline==0.1.7
+mdurl==0.1.2
+mergedeep==1.3.4
+ml-dtypes==0.4.1
+ml_collections==1.0.0
+mpmath==1.3.0
+msgpack==1.1.0
+msgpack-numpy==0.4.8
+multidict==6.4.4
+multiprocess==0.70.16
+mypy_extensions==1.1.0
+nest-asyncio==1.6.0
+networkx==3.5
+nodeenv==1.9.1
+numpy==1.26.4
+numpydantic==1.6.9
+nvidia-cublas-cu12==12.8.4.1
+nvidia-cuda-cupti-cu12==12.8.90
+nvidia-cuda-nvcc-cu12==12.9.41
+nvidia-cuda-nvrtc-cu12==12.8.93
+nvidia-cuda-runtime-cu12==12.8.90
+nvidia-cudnn-cu12==9.10.2.21
+nvidia-cufft-cu12==11.3.3.83
+nvidia-cufile-cu12==1.13.1.3
+nvidia-curand-cu12==10.3.9.90
+nvidia-cusolver-cu12==11.7.3.90
+nvidia-cusparse-cu12==12.5.8.93
+nvidia-cusparselt-cu12==0.7.1
+nvidia-ml-py==12.575.51
+nvidia-nccl-cu12==2.27.5
+nvidia-nvjitlink-cu12==12.8.93
+nvidia-nvshmem-cu12==3.4.5
+nvidia-nvtx-cu12==12.8.90
+oauthlib==3.2.2
+opencv-python==4.11.0.86
+opencv-python-headless==4.11.0.86
+openpi==0.1.0
+openpi-client==0.1.0
+opt_einsum==3.4.0
+optax==0.2.4
+orbax-checkpoint==0.11.13
+orderly-set==5.4.1
+packaging==25.0
+pandas==2.2.3
+parso==0.8.4
+pexpect==4.9.0
+pfzy==0.3.4
+pillow==11.2.1
+platformdirs==4.3.8
+pluggy==1.6.0
+polars==1.30.0
+pre_commit==4.2.0
+prompt_toolkit==3.0.51
+propcache==0.3.1
+proto-plus==1.26.1
+protobuf==4.25.8
+psutil==7.0.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pyarrow==24.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pydantic==2.11.5
+pydantic_core==2.33.2
+Pygments==2.19.1
+pynput==1.8.1
+pynvml==12.0.0
+pyparsing==3.2.3
+pyserial==3.5
+pytest==8.3.5
+python-dateutil==2.9.0.post0
+python-xlib==0.33
+pytz==2025.2
+PyYAML==6.0.2
+pyyaml-include==1.4.1
+pyzmq==26.4.0
+regex==2024.11.6
+requests==2.32.3
+requests-oauthlib==2.0.0
+rerun-sdk==0.26.2
+rich==14.0.0
+rsa==4.9.1
+ruff==0.11.12
+safetensors==0.5.3
+scipy==1.15.3
+sentencepiece==0.2.0
+sentry-sdk==2.29.1
+setuptools==80.9.0
+shtab==1.7.2
+simplejson==3.20.1
+six==1.17.0
+smmap==5.0.2
+stack-data==0.6.3
+svgwrite==1.4.3
+sympy==1.14.0
+tensorstore==0.1.74
+termcolor==3.1.0
+tokenizers==0.21.1
+toml==0.10.2
+toolz==1.0.0
+torch==2.10.0
+torchcodec==0.10.0
+torchvision==0.25.0
+tornado==6.5.1
+tqdm==4.67.1
+tqdm-loggable==0.2
+traitlets==5.14.3
+transformers==4.53.2
+Tree==0.2.4
+treescope==0.1.9
+triton==3.6.0
+typeguard==4.4.2
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+typing_extensions==4.13.2
+tyro==0.9.22
+tzdata==2025.2
+urllib3==2.4.0
+virtualenv==20.31.2
+wadler_lindig==0.1.6
+wandb==0.24.2
+wcwidth==0.2.13
+websockets==15.0.1
+widgetsnbextension==4.0.14
+wrapt==1.14.1
+xpolicylab==0.0.1
+xxhash==3.5.0
+yarl==1.20.0
+zipp==3.22.0

real_inference/manifest.sha256

@@ -0,0 +1,207 @@
+d247d7fc20b2c48c22ff64c6efb7e19bb47e064e38386585f22e6b25943c7f80  README.md
+9a856e6c5c804d0fd4b73a84bb440b7f05a8b659a560e0d469ae442434a02c81  check_fixture.py
+c253e55558c7a8350c668837fbca96ea61bb3cad4ad0cb24154b3286584df22a  environments/act_pip_freeze.txt
+e3669e71e38410773cb9700d0d477fd12770f454d980d1f4884cf33d7090bd4b  environments/dp_pip_freeze.txt
+e92774979d8acee5eee4ecfadc9fcaf3ee201b3a54faa747b27fa9b038970cec  environments/pi05_packages.txt
+3c0a343d3e47fbace99a902f0c1251926b748002c91fc8ae56c343f08c86e6d2  fixtures/0041_episode0_frame100.npz
+9bfe8de73a8b29e6fd335c73135ed125e6777c0d5fad070207c0df3088443651  models/act/dataset_stats.pkl
+8cc45d9a95d8942102368d4ade28ce3b1e2c2a40b3b5c5447af4bfba5d16b2b6  models/act/policy_best.ckpt
+d3096f7b7744259761819ba47ecf72a9d76e756a105fdb4e07b3d64682fb7dce  models/dp/10.ckpt
+3a22a8e6c9e8db04d6231f0c43bcdecd60625edbd08626eb275f380d069965b1  models/pi05/29999/_CHECKPOINT_METADATA
+431056d043a070e22c993fd83bf1837485b4ab00757b6d1ba356e973b9f12065  models/pi05/29999/assets/aloha_garment/norm_stats.json
+88464a384c524c50fa1a92c1685d23a79570c62807a0ccf021f5f9307fff137c  models/pi05/29999/params/_METADATA
+54899ee3f4d45eee96ddada379a19a9da1324792b141fa0449608620571e6b01  models/pi05/29999/params/_sharding
+da5f8952b77ab352fa92e3e58d742bfe0db5b9c1b956212f8279895b9df03721  models/pi05/29999/params/array_metadatas/process_0
+07f9785cf62e6bfa977b4da86fb4213d7eaa9813ac090df1a3a6101d95933a0d  models/pi05/29999/params/d/06333319d86d6322317baf3a3eac4ad0
+aaaa5de82859481d737cbfdc83c79a24766e4d3b5ebe5f3d223e6901f6ce1575  models/pi05/29999/params/manifest.ocdbt
+e94b6f05ceef55173200b9a654bc6d84fae3656f3c7e168fafc6291a2847bc7a  models/pi05/29999/params/ocdbt.process_0/d/366797c577724144889229f01578f9bd
+a7529dbe32d1effa51ffc7ccea0cc8fe6ed7457c7c6769b7acc5621b583102ec  models/pi05/29999/params/ocdbt.process_0/d/780a5b6463312c36c65b532cb5c5c630
+75b7f446e5fb5a304b7989c76077152a72ebf21f2d6cee57f8a8cde1471e4a48  models/pi05/29999/params/ocdbt.process_0/d/8326f82906296621ce83e0ef00b39dcf
+846141ddc272b836589ee4359cf3c4ce65ed8e4fddd75f9a1b18db189f2f0431  models/pi05/29999/params/ocdbt.process_0/d/863f8f5edafc9c0283c9c0e39f8bb80b
+bbbb9f85d7dcdffa058288d36dd4b77e49f4fd314eb96bbed53c70fcdb0e43aa  models/pi05/29999/params/ocdbt.process_0/d/88272c645a2a08ab0ea0a491f721c696
+1ecfb7b2d39c7e35a2255bdbeb0bf840f86ea48dc5c8894033f29bbe469fe429  models/pi05/29999/params/ocdbt.process_0/d/97a38f866cf57e5ac239d6dd5e3ecb4d
+c5bf3363ca850197ec394367a792a47f110a8acc5060423f72c1a1cae251776b  models/pi05/29999/params/ocdbt.process_0/d/a092f4574281d2f0ae1f037e702c3197
+efd26dd1e0ca4a1a708b29a1b181d70dbf46bd521e7e5c182900bc66f17956cb  models/pi05/29999/params/ocdbt.process_0/d/d3974835cdb6b10d70315290f2a85cbc
+90d24d7766bf7713f33b14c2baf86b0e7a43688699cbcad13d34d45445af8bc2  models/pi05/29999/params/ocdbt.process_0/d/e17de3b568a701ef9e6f1a35243d6f92
+d4f04e9be9adf4bb451735599d8d9d644de3465414abe5d96eb497776bbeec6c  models/pi05/29999/params/ocdbt.process_0/manifest.ocdbt
+f642d4038df7bf98addfd10db1b7d7c54c030aa2f42f4d3f1dd15cbd7a237d33  models/pi05/29999/train_state/_METADATA
+ab273f886dd11d3933e8c13cd73ec9994da4259378dfa90609d02ab62e72968e  models/pi05/29999/train_state/_sharding
+c34703e55a203ddc31398d036b36f1b4dbf3526d3078442c1118b65c2e188a1e  models/pi05/29999/train_state/array_metadatas/process_0
+335bd3ea39a7d4cdefb7e8f74d16906a4fb93eff9f3511d3fc8aded22195a649  models/pi05/29999/train_state/d/54d554dcf73117307fd5fc1be16e9d3a
+6805f0c42d560e5052aa3c1bfb13f91f386d1737b7dbf38bdc4cfbe3e0181096  models/pi05/29999/train_state/manifest.ocdbt
+f5f07a5628102c460a35c1799e565092abbfdcc8fea4dbb2d0da03309ba35945  models/pi05/29999/train_state/ocdbt.process_0/d/431a2806b246e72e9fd091a350a7c94d
+1c1a10df6d4422e44a53495b4cb5d46322f2a5cdc47af5f2c3a34d35e33d991f  models/pi05/29999/train_state/ocdbt.process_0/d/515c0ef0445b4ef38fc13c6478d474bc
+4322e96cd3829e98d2a117a6ec7128cdaa27f5f3a65c63fc53133c63c1413e9b  models/pi05/29999/train_state/ocdbt.process_0/d/7137c5918b57537691d56243eb5926f8
+2e7709a2f3ab837541deb5b19191b5564f34ee3934b8fefe154f5965045f9671  models/pi05/29999/train_state/ocdbt.process_0/d/fce79687f9af6009dbecb732076e5547
+6feb64c62938b4018120e5269ed9c150060d17daf6243b3bdbdab62c301d3a54  models/pi05/29999/train_state/ocdbt.process_0/manifest.ocdbt
+8986bb4f423f07f8c7f70d0dbe3526fb2316056c17bae71b1ea975e77a168fc6  models/shared/openpi/big_vision/paligemma_tokenizer.model
+f37072fd47e89c5e827621c5baffa7500819f7896bbacec160b1a16c560e07ec  models/shared/torch/hub/checkpoints/resnet18-f37072fd.pth
+a60066840d7b34f3797a6a19b4d27d42339645116edd0f749f4c9315bfac34cb  provenance.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  reference/deform_manip_sim/__init__.py
+6895cabcabc21dfcc8b09e7b8ec83b5558d8162a9c61b9fcc8592f71845ee419  reference/deform_manip_sim/policy/__init__.py
+7acc2687fdc644a2016e93a153781e219838c823f930751d37968ac017129f0e  reference/deform_manip_sim/policy/aloha/__init__.py
+c804c2ec33d43d4177c8e2a8f6c22d13f1513d61185bbb7e63244a93721c7665  reference/deform_manip_sim/policy/aloha/adapters.py
+7fedc104b039893cd332c42ef357a5ef5b64402e0d00bb46f70ac488b4068ac4  reference/deform_manip_sim/policy/bridge_client.py
+fb7b87236875b7e29aaebb79ec210718d16ef456be73be32c6cb3e20f79e1e85  reference/deform_manip_sim/policy/schema.py
+58147eced98404580b604122b0a43ab02e709fd6552d26fb7c9e733545cc0fc5  reference/scripts/serve_policy.py
+c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4  source/XPolicyLab/LICENSE
+3c7b0d9bcd054154d4246a7783c09d269d2a262c6b008dfc3b49988185b33500  source/XPolicyLab/policy/ACT/detr/.gitignore
+b208c52b00a2df2c8f4c3298c34407bf2bfe409968213372251c91fcc737a1a5  source/XPolicyLab/policy/ACT/detr/LICENSE
+56f4d26214510a82e532dfd452bb06bb143f8f04300dc2017fa04149e5323fc3  source/XPolicyLab/policy/ACT/detr/act_policy.py
+dd4e8cab2b0e721a7da644c9d16520490a8b558c685affe95bb9a1ca13be1661  source/XPolicyLab/policy/ACT/detr/detr.egg-info/PKG-INFO
+333ba1359bc7c12f06e440e9173c33c94d0fe04dbbe65a8a53011093ba7c5f71  source/XPolicyLab/policy/ACT/detr/detr.egg-info/SOURCES.txt
+01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b  source/XPolicyLab/policy/ACT/detr/detr.egg-info/dependency_links.txt
+e104c6b3e081b16e5cd3606769d0f11e6c5fd71828431fc894edff0a9ca7e119  source/XPolicyLab/policy/ACT/detr/detr.egg-info/top_level.txt
+5db61b9312644ce0421d110079e4aed2baf442bd6fa5eae6d6a5be26d3a57b9c  source/XPolicyLab/policy/ACT/detr/main.py
+3c09396628dc91ed32b59beeedb4f818fbd7bf3e5154b728513063ecdc0ac1c5  source/XPolicyLab/policy/ACT/detr/models/__init__.py
+476d954304220c4d34fa9eb725ea2eaa54da72be452e8a645e19989f95880aee  source/XPolicyLab/policy/ACT/detr/models/backbone.py
+292e0e78997941ab8a8c592ffb3f88960e5971ffb0f621b9ff02fb942db45306  source/XPolicyLab/policy/ACT/detr/models/detr_vae.py
+12578dbadbaea2d8252c43f818b5826b1cf141feb8df1de2a012da81138080e4  source/XPolicyLab/policy/ACT/detr/models/position_encoding.py
+837506820a3c564896d9d694681b9a803c14e6ec30081ec9336f493158c06f4b  source/XPolicyLab/policy/ACT/detr/models/transformer.py
+32e7e93134ab194d05c8f02495d53264b9956ee8d7e0cfac2a3fd63881ef0c46  source/XPolicyLab/policy/ACT/detr/process_data.py
+9a44d0125d73963ca219fd16cb511426b5fa2dfb7a499b7d9f08422ab822ccfe  source/XPolicyLab/policy/ACT/detr/setup.py
+9e535c45af09ac24ef8d5631a151f77febafe72a92ad6bfeb2d941f0c4a54e35  source/XPolicyLab/policy/ACT/detr/util/__init__.py
+4c28aba49a4bb3ff18385e4940ad8ca7ad788aa4cfb03b075d15d9b4294d6aa6  source/XPolicyLab/policy/ACT/detr/util/box_ops.py
+f9210613ef5d7477c01ad1cc6946c36a0221102cf6159ad7c261dd20b8feb374  source/XPolicyLab/policy/ACT/detr/util/misc.py
+e8d46523fbf7aca10c2911be55441685e0cd1a6f4faa7382fcefb62c06b3bdca  source/XPolicyLab/policy/ACT/detr/util/plot_utils.py
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  source/XPolicyLab/policy/DP/diffusion_policy/__init__.py
+41bc1e81aa2f988eb0aaf134baea592e5c7fa9486330b2db85307de91cf48a77  source/XPolicyLab/policy/DP/diffusion_policy/common/checkpoint_util.py
+c26440ec98788d7bcb9a839573a0eb2c6e6fe2395acc240b62e71f95365168bd  source/XPolicyLab/policy/DP/diffusion_policy/common/cv2_util.py
+2ac6e9b690b38ef5c9671dd1b238955857f803e8d623cc32b1fb28e236c472fe  source/XPolicyLab/policy/DP/diffusion_policy/common/env_util.py
+ca6884937e1e6f5c7a7afa079f413bf1137178e1a6627ec152c2cae792dbd4c7  source/XPolicyLab/policy/DP/diffusion_policy/common/json_logger.py
+4aa208dbcc298489854678b88b06e18b672dd776670e67ba65305e9158a6e1eb  source/XPolicyLab/policy/DP/diffusion_policy/common/nested_dict_util.py
+78376a000e4ac189df9777250b27a7559255647ba407d16f8a8a8e7e96aca55e  source/XPolicyLab/policy/DP/diffusion_policy/common/normalize_util.py
+feedb5130eb3267198957cf5ff2507c76ec0f48196944cac34ca2a46426104e7  source/XPolicyLab/policy/DP/diffusion_policy/common/pose_trajectory_interpolator.py
+b82bd5ed3d5a116aa0097a2a16b0db35fa5e1bce38fc5a2ea37fe2b322f2e8d3  source/XPolicyLab/policy/DP/diffusion_policy/common/precise_sleep.py
+92c8059f9d8fb551193ccf135272318ab43d796cf8a8af3492156fcb297b4740  source/XPolicyLab/policy/DP/diffusion_policy/common/pymunk_override.py
+3190b005acd101408e7226b658077a5f27772d6b59f1fe8b642ee527b160e054  source/XPolicyLab/policy/DP/diffusion_policy/common/pymunk_util.py
+ce68ea9aa3eaad156364ff58ed842026406c00e07ed9b632445d3b5c6f8620a9  source/XPolicyLab/policy/DP/diffusion_policy/common/pytorch_util.py
+11ba406b5bd88fa05680072e70ea414a61d7788295741a0efadb6d49873523da  source/XPolicyLab/policy/DP/diffusion_policy/common/replay_buffer.py
+d7424c5e1931b24ecc4acbd869b4771dce91eb844f83d8ca093bda91bd68fb3c  source/XPolicyLab/policy/DP/diffusion_policy/common/robomimic_config_util.py
+7862574196c70f71cb64a64906c6e87ec56ce1beaee80a405e70222decab5d80  source/XPolicyLab/policy/DP/diffusion_policy/common/robomimic_util.py
+879bfab2bf068816d3952c814325c8fd989dabc9fa688ce7f859c9234b3f3b2f  source/XPolicyLab/policy/DP/diffusion_policy/common/sampler.py
+d568552511c1b3ef158ec6146acfad1e1e187357daaca35ed6688752ee5c8eb8  source/XPolicyLab/policy/DP/diffusion_policy/common/timestamp_accumulator.py
+44a7c934ad0f5253705f65a16fba102a757f445e7b93b03d1f07c907359fd4dd  source/XPolicyLab/policy/DP/diffusion_policy/config/robot_dp.yaml
+0d4214c41cd2d045590acd37ed6633f808d15ac2451c286c62e206f3458ae8f1  source/XPolicyLab/policy/DP/diffusion_policy/config/task/aloha_garment.yaml
+d1ed4fcbac031ca7d507f6471aef8c033afadb000749178a47e9558ed8f8a271  source/XPolicyLab/policy/DP/diffusion_policy/config/task/default_task.yaml
+7cd18962090681d6f8ccf2e16e90ce4217335bb16d2ef10badfc29a21ab028ab  source/XPolicyLab/policy/DP/diffusion_policy/dataset/base_dataset.py
+dfd33a488fe2fd38b383936284edaaa02f5215cae5e0b215d36d19d647ae4782  source/XPolicyLab/policy/DP/diffusion_policy/dataset/robot_image_dataset.py
+aba2e5f21bc48d64cb90e8aa3f59c5bce7ff57eadd30289dd29e7cc3dbaf1e27  source/XPolicyLab/policy/DP/diffusion_policy/env_runner/dp_runner.py
+e90b80222484c9d8602ee2e0d49a20c744d5e102da6ac95ba93358562ca1df0b  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/action_ae/__init__.py
+0cfa8991f05c29f73536b8cb8ba1ce8a5141df8ffdb59be869a46cf0cf301b5a  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/action_ae/discretizers/k_means.py
+a92d651b1aee0bd6301ed4f138ae04faa3cbabbac5d874d6352b3254fe798315  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/latent_generators/latent_generator.py
+c50a2b5f414dc1f4bf756d41c9c5e30237fb216a7f97505bb48c486e9946a45e  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/latent_generators/mingpt.py
+0873c819f7dd26a858944345eebe8a11c7eb82f4fb3835595e53d1d600cd1072  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/latent_generators/transformer.py
+ac1a796e62fae864f78cfae9780dac510460f4c33bf2732c5dc508fdca4029b4  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/libraries/loss_fn.py
+1868a048bfe0f991cf82ee0f8c357b50887bc32549a47762dbca96e87ebb9483  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/libraries/mingpt/LICENSE
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/libraries/mingpt/__init__.py
+e85b9ad8c098cdae2b81fc09e835cf4a217c5e6f1cf8e265b10beaa34f739f34  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/libraries/mingpt/model.py
+397620fbdb3b2c0e4bf021c5a6d0889d7c8d69e139d9fa091d584c2e6da56bc9  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/libraries/mingpt/trainer.py
+c875b0a8615564b768bccd674fba3d1a9faa8524cdc0640bf2dfc6c4b30d314e  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/libraries/mingpt/utils.py
+3b5c34ecbf6bb54182199811771eeb35dee2712e68fe90d5ba1c5c107e28c2fa  source/XPolicyLab/policy/DP/diffusion_policy/model/bet/utils.py
+ff3be833276dda9d395f6204aec6769f30317a68c8634ab37d7f375e274be1f0  source/XPolicyLab/policy/DP/diffusion_policy/model/common/dict_of_tensor_mixin.py
+3e91c244c0be4a4d758388e6db5882b9d616467239f5eef99a2d2d0e2a5636eb  source/XPolicyLab/policy/DP/diffusion_policy/model/common/lr_scheduler.py
+37bb26e0ac9bcba6161dba613929d9d3f475f2bba683885fcb49df323d6dade7  source/XPolicyLab/policy/DP/diffusion_policy/model/common/module_attr_mixin.py
+6360c630fbe134dd7b311d279977104212c68b5987e54134fdfe64fc9cba0ae8  source/XPolicyLab/policy/DP/diffusion_policy/model/common/normalizer.py
+af505851e7a530bda4f596801f5e44ae075846b2667d6c93148314d9a2cc044d  source/XPolicyLab/policy/DP/diffusion_policy/model/common/rotation_transformer.py
+9751d6dc7342877a455a36fbccb4df6fb515cdb3b5ecbd2873e6d5c8fc876d3a  source/XPolicyLab/policy/DP/diffusion_policy/model/common/shape_util.py
+3a00f0a6bada6490944f31502cfa3ed515515b91145d1d4146f11c4eb0e510dd  source/XPolicyLab/policy/DP/diffusion_policy/model/common/tensor_util.py
+332a392e168ae4642ab197f1934bc2cf5c10010b994f9b2ed9975b90ee0f8c67  source/XPolicyLab/policy/DP/diffusion_policy/model/diffusion/conditional_unet1d.py
+4342ecb9391ffd053aadf38d4c833b5a7d68b79b442572fd1d786c07f1a9f12e  source/XPolicyLab/policy/DP/diffusion_policy/model/diffusion/conv1d_components.py
+c6f1ae757bb2b10e5d20d5875d9c8c7a1c620aa4ecea6424a87b4b1bea76bd1a  source/XPolicyLab/policy/DP/diffusion_policy/model/diffusion/ema_model.py
+d646443f3f2e3379d1e7b535605466248a851a86836136934deb75c1356614e5  source/XPolicyLab/policy/DP/diffusion_policy/model/diffusion/mask_generator.py
+87eaca54c0037e6084c6401425e9548b141366be3e5ab1544a6fdd24ae7d4e59  source/XPolicyLab/policy/DP/diffusion_policy/model/diffusion/positional_embedding.py
+76f9ea5ead2ca166a9868167ea49fbce018eb924960e05892eba2976b4945b03  source/XPolicyLab/policy/DP/diffusion_policy/model/diffusion/transformer_for_diffusion.py
+ea7ca0e4ce7192b89d0ce70a6f0c056084480ac24b08063a8e5b191d4b1a247a  source/XPolicyLab/policy/DP/diffusion_policy/model/vision/crop_randomizer.py
+07615235ef9675c47549712eb7d3f6764d6f9dad30c543f86c5a82ca322b0638  source/XPolicyLab/policy/DP/diffusion_policy/model/vision/model_getter.py
+68c446d507b29707153ef9a17342c399e3595321f83a23289a65e0d8a37e0f15  source/XPolicyLab/policy/DP/diffusion_policy/model/vision/multi_image_obs_encoder.py
+3765eda42f717caabf5d488e0e456adbc82133f516747163b4de4194102e8512  source/XPolicyLab/policy/DP/diffusion_policy/policy/base_image_policy.py
+d5a50e36b6e57eb52267e8c35f87c8451ce74b66f043cf723198246a19b65181  source/XPolicyLab/policy/DP/diffusion_policy/policy/diffusion_unet_image_policy.py
+ad39f770def1b305860e040c14489e6be7e30a7cfc405fe66640a6d11caf0789  source/XPolicyLab/policy/DP/diffusion_policy/process_data.py
+3409e41508f14718ab73ca6d26c854fda533228e2262be6c7aa7e51628e0a651  source/XPolicyLab/policy/DP/diffusion_policy/shared_memory/shared_memory_queue.py
+c5f8d45da42b2581a6220a2f5efead87756d4785bb3b1ccd78e13846d85b29c6  source/XPolicyLab/policy/DP/diffusion_policy/shared_memory/shared_memory_ring_buffer.py
+4683afe1d810c25e941d75a2dc121e73353c422bfd41c105fc5f5ab3bb75efa7  source/XPolicyLab/policy/DP/diffusion_policy/shared_memory/shared_memory_util.py
+11f4a2dbb9b3722d36419b617b585d155ff5c55e8c15bb775d8f5c45de78bca6  source/XPolicyLab/policy/DP/diffusion_policy/shared_memory/shared_ndarray.py
+9e0a457e7d2c90409b7bec3723b61640e40a8f83a89b8eefd0652fa3602418ef  source/XPolicyLab/policy/DP/diffusion_policy/workspace/base_workspace.py
+265307f01e353e84cadfe7981541809c6a7fb99cf0c19ddf3fb02c8fe2a0b5a0  source/XPolicyLab/policy/DP/diffusion_policy/workspace/robotworkspace.py
+bb0635f951bfd55419a47fc08a859192049b4d0949cf2d09a4d4d6b2cafafb94  source/XPolicyLab/policy/Pi_05/openpi/.python-version
+43070e2d4e532684de521b885f385d0841030efa2b1a20bafb76133a5e1379c1  source/XPolicyLab/policy/Pi_05/openpi/LICENSE
+3e2c24001f9ef57bf7ec959a3658fbb49cdad113cdf394c264da9d16f9bdd132  source/XPolicyLab/policy/Pi_05/openpi/LICENSE_GEMMA.txt
+567fc57766bd736664f50126cab8145af4071ca16cc5e238f2b11e369169c3b5  source/XPolicyLab/policy/Pi_05/openpi/README.md
+00e8cb0e589d8f473588528f271f780fbe20cb67ba778e3e827d30cc3eb6cc92  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/pyproject.toml
+91447944015cec709e8aa7655f7e9d64e1e4508e7023a57fe3746911c0fc6fed  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/__init__.py
+019b9d69cb26cc681331a2f95dbe60a2cc7b02d6d309c5d15b6457ab39798234  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/action_chunk_broker.py
+88e98e0f06293f3c4767db675061664c4bba12f87242ba1e64377d1b8de8069e  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/base_policy.py
+d48b4bd7f44e79fe6db8a8e07c9161144fa250be686e1245014a8b47e6171977  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/image_tools.py
+4df4b0ba0b95ba5e47160039c3e837a64d50c802b419a588211dffbaa732589c  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/image_tools_test.py
+c04568948fcee52b691e3be4b6cffb759f7e79ad67530fcd5d23095a0d13c057  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/msgpack_numpy.py
+2c6dd236720dae716d7bdf842b7d506a165e9563bf9d4376c95289269adcb973  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/msgpack_numpy_test.py
+b559885afd9645a91b9b6ee12a28513295474f987d11b16610fc0479dbe6de5b  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/runtime/agent.py
+c4d63952d1954bd4b72a3122223df36794812fea74cf1c7023433b5a90473c1c  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/runtime/agents/policy_agent.py
+1c12e5054b3401dec5f1f8b71eef0f625cb60e2b50784dcf19afa32c77107a7e  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/runtime/environment.py
+3daa242a9ce61ffb210789ef3ba6b1e3cade9de757fcd36af7b174c530345ea8  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/runtime/runtime.py
+d269a2af8ec4056beb310e5c3c97d4468af01549c7ef80dd905652d8ac64f85b  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/runtime/subscriber.py
+36557cb0b91ccf31cd4fb4b508306850d76ed0feb4028dac5182d0f5a5d88005  source/XPolicyLab/policy/Pi_05/openpi/packages/openpi-client/src/openpi_client/websocket_client_policy.py
+83333f95befe8ae5649c3ab070ab93c74736efcb51c518a6248af338b2148709  source/XPolicyLab/policy/Pi_05/openpi/pyproject.toml
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/__init__.py
+626672e385fb276396c119e2220421065c58f8ec602401e8bf2ae509f9fffaf3  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/conftest.py
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/__init__.py
+7e42ada4ae7e9995f0ef3e33a0c224758323c2015e2d9d72ec15726a8a001d2a  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/gemma.py
+563c6e1ffd8afa31c406bcb8894a605e87df88f6c075d398d97a57af6bc3aefa  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/gemma_fast.py
+ced28716950c34d84a1a6d0b03b1d9550000732721df884818080b6e78cb3289  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/lora.py
+a0f10525de7773310402b3ffa636e88ffff7035f3179b140aacc6809c122f085  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/lora_test.py
+0d74bc1d8f4623ac3d8e543710b8bf75f9b95e588a3ebf6127c659e001385cff  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/model.py
+f8e71f195045d4e3ef1ddfafb2337fa52e5aa2f89bce1fde62f5cbfb67121f21  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/model_test.py
+24b32d7c6ed5e409459afa8ca5af96a4dae09c2dcdf48e828907e411f4f12342  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/pi0.py
+d321858c30b398126035ea2b6da09e1c422eeeebb5ebf8df631daf9dc77647fa  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/pi0_config.py
+627332a555046f2744ef144c45f8bd3361a9820cf68854a4528d0fdbba7e9aa3  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/pi0_fast.py
+5082873014a7fc45fb8414f517909e1c24cdafea980a1fb612e0aea6058ed0fe  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/pi0_test.py
+14b4df0be280d5769fb0dc31a40cde27525dbb1980cc998c28475d62fa3cad32  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/siglip.py
+965be8b3c393a6811875bbc32da9e01a5d01cc2f87802de801cf7293e049748c  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/tokenizer.py
+5abd179ce883420e39d4d18b33d0123290af752da243003aa48a3bc06dbb9517  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/tokenizer_test.py
+88866638ee4775f46a222561a957bd35e20600fe38c5888b587016ad77b1065f  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/utils/fsq_tokenizer.py
+d285d057636c3cba2d1fd3b37693b18075ad4b9c3b47bbde807c34c6c376ac93  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/vit.py
+08fd8d750519f0fb44fc5173311e50a30f4c8f32c02e51244b4f8e47b32cd52f  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models_pytorch/gemma_pytorch.py
+dcd7b6f508808ce4b7170a1720a4c62c6da04edae3652d16c94a469dca924e16  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models_pytorch/pi0_pytorch.py
+6a44e91be2d7a724c6140d2cc98ed0a631b8d38bbb29f63b380a0a19f903bbf6  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models_pytorch/preprocessing_pytorch.py
+26fd0d0f52730ab32b6f337eb73ae9a26cb71ae0915bc49eced1d0e2ed8d0ec6  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models_pytorch/transformers_replace/models/gemma/configuration_gemma.py
+17eeb54e277939e58cd6f8a92719a275e36baf0c9f463b2754227d42f87aedde  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models_pytorch/transformers_replace/models/gemma/modeling_gemma.py
+c945d330b829264f927f3ee5339f977238631772de07a28e855e265bb85fd53c  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models_pytorch/transformers_replace/models/paligemma/modeling_paligemma.py
+466e8eb7887ac5ccc98118a3169298d6ab65a284d834bae74751e3854dbc4245  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models_pytorch/transformers_replace/models/siglip/check.py
+ef2e99500f263fdd78db9d4d9a255e29d844eb92f53c25ad640f8056700ef84b  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models_pytorch/transformers_replace/models/siglip/modeling_siglip.py
+c37aa90797665b1ec57cd5286fa5d6cbf29af0559ffce36d3fed98c02329eaea  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/policies/aloha_policy.py
+7d0893555964d485e231f70084125084a99495705ddd74b29461229d524fff26  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/policies/droid_policy.py
+ad01e5be74516d9ec9aeb1f76294d5c9f7f7179a60f1f7fbbb35e7646534f81a  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/policies/libero_policy.py
+509b8ffb151060f7373527d575bbb67f74a1877c592272eae07d7a680d454742  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/policies/pika_bimanual_policy.py
+429f4be0309e0c7533a84b6719363d2b4b03ceecec3b82d48bf38043585abc17  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/policies/pika_bimanual_policy_test.py
+5a19b73e8d9c60a9e21849bf482c0e9c72f454c3aa88f2de544a24f209913b99  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/policies/policy.py
+aaf42ab04a33b6c91d2447926211646c33ebd8ebfa427f026d7b6c4f7c45ec52  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/policies/policy_config.py
+9dbb20963600367a7e7abfc97d1e326916777c57a87b39b1bc4070ba64676683  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/policies/policy_test.py
+98046d038740dff6ebf41b0e3bf59674ac30246332a33cfc0624e5a06c855310  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/policies/wuji_policy.py
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/py.typed
+1370d345e6c3c5b8f15573050e485e60a5b423d1df33e24b237805e6b442b026  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/serving/websocket_policy_server.py
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/__init__.py
+6524945566eab3eb97b75a6280ba4724617b4d028c55f05172b283c3de68a026  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/array_typing.py
+ed0c86bf70796c5211908d6fe728334ab9a12dcca9d9b55ba801f8246ed7ecae  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/download.py
+234ee70ab2501a1421f6c44cbd83c1e16747597023319ae1446bed9d44f17072  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/download_test.py
+0f8fcb355288119e56acb56d550c1cc1f3a9edddceb0dc5b319f955943ef7767  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/image_tools.py
+842374579dc9f4c2907da5e8bb555efe5a3f4902b659720c8e90115863dd59fe  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/image_tools_test.py
+4da7111ba3011c4d1c381c9ed17257771df6a50ed89182647c3fb6f79208005e  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/nnx_utils.py
+6c2cea4946fb07e51801530400d2b2fd94730e195cd290d6b6960114eca9739d  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/normalize.py
+fda27a21cf37f337b12bcab71229407c2a349c5965c33f278bdc468ed03f58af  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/normalize_test.py
+3cc32682ec3609e9075dabd991488edb9d7f6c045443f58963d733f99c468dbd  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/checkpoints.py
+b224ba8a661c1f3f6ddc70c2cb0159b842065d9688fd4280ff848f8821c4f99f  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/config.py
+21ed6c95ae43edc7c9cb9b7684187f0f38c4949ad366c826e499df59952660ee  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/data_loader.py
+a0cf1bc293e8b0eb9bc5516bc05d30d9940da06c94fcfa1addca7267f8358815  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/data_loader_test.py
+1d3a057a040240218234d7dbc6680ee4fe8256f2058531a0f9fefd3f7ee995a4  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/droid_rlds_dataset.py
+c2ab92efb5e0d675118ad812113fd1c3cb3a62cdab5d79066014266e82df12d8  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/misc/polaris_config.py
+914acdd74ccf90e6779c13a5093140595c7e4f687e9e0b167439446a81d74c01  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/misc/roboarena_config.py
+cfb5d6f6aec61fbe961287b4015c652260628a0ed4682a0dbdc271b8e65431fa  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/optimizer.py
+c67c4112a126ab097571c8a882fd1ee3f106b15b6e608e7205ac7f29b44ca985  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/sharding.py
+b684e674343f86ef5e976f279a586d3fe2f885e901f396ac899ed136abc7eca6  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/utils.py
+ef98cee058972ef54269c2a41f81ad265bc3f137432044824c09e1a0462ef714  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/training/weight_loaders.py
+9f40be2871c01f42f1a58e60fdc3b20641cff87bb147abc3be8fdbc8ae39aaf8  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/transforms.py
+f84cb46a5c4b4bd819871376038c35da8662d85f67a2284822ea068d610fb2fb  source/XPolicyLab/policy/Pi_05/openpi/src/openpi/transforms_test.py
+2ffa14b9cb4c46791b11785cab6a003cca70fa696f8db3af52fc6e745a15b1e8  source/XPolicyLab/policy/Pi_05/openpi/uv.lock
+837e79146271a02da46ed20ee619c267adc1979fa7589cc1c0a78c467b81979f  source/xpolicylab_local_changes.patch
+d14af952c5234e43d41b3dae24f05aa0cb265548114b4d65c2357bd106a97fb7  verify_files.py

real_inference/provenance.json

@@ -0,0 +1,31 @@
+{
+  "xpolicylab_git_commit": "1e815ad750ba27407ec2e1a97cb4674a43d0734d",
+  "source_snapshot": "selected actual server working tree including uncommitted changes",
+  "model_files": {
+    "act": "models/act/policy_best.ckpt",
+    "act_stats": "models/act/dataset_stats.pkl",
+    "dp": "models/dp/10.ckpt",
+    "pi05": "models/pi05/29999",
+    "pi05_tokenizer": "models/shared/openpi/big_vision/paligemma_tokenizer.model"
+  },
+  "fixture": "fixtures/0041_episode0_frame100.npz",
+  "instruction": "Fold the garment.",
+  "camera_order": [
+    "cam_high",
+    "cam_left_wrist",
+    "cam_right_wrist"
+  ],
+  "action_order": [
+    "left_joint_1_to_6",
+    "left_gripper",
+    "right_joint_1_to_6",
+    "right_gripper"
+  ],
+  "dt_seconds": 0.04,
+  "act_prediction_steps": 50,
+  "dp_observation_steps": 3,
+  "dp_prediction_horizon": 8,
+  "dp_executable_steps": 6,
+  "pi05_prediction_steps": 50,
+  "pi05_replan_steps": 5
+}

real_inference/reference/deform_manip_sim/policy/__init__.py

@@ -0,0 +1 @@
+"""Minimal policy protocol package for the offline reference adapter."""

real_inference/reference/deform_manip_sim/policy/aloha/__init__.py

@@ -0,0 +1 @@
+"""Adapters for dual-Piper three-camera Aloha policies."""

real_inference/reference/deform_manip_sim/policy/aloha/adapters.py

@@ -0,0 +1,89 @@
+"""Checkpoint-specific policy adapters, loaded in each policy's own environment."""
+from collections import deque
+from pathlib import Path
+import os, pickle, sys
+import numpy as np
+from deform_manip_sim.policy.schema import ActionChunk
+
+ROOT=Path('/data2/wushuang/my_projects/RoboDojo/XPolicyLab')
+CAMERAS=('cam_high','cam_left_wrist','cam_right_wrist')
+DT=.04
+
+def _images(obs):
+    missing=set(CAMERAS)-set(obs.images)
+    if missing: raise ValueError(f'Aloha policy needs three cameras; missing {sorted(missing)}')
+    return {k:np.asarray(obs.images[k],dtype=np.uint8) for k in CAMERAS}
+
+class ACTAdapter:
+    def __init__(self):
+        import argparse,torch
+        os.environ['ACT_ACTION_DIM']='14'
+        sys.path.insert(0,str(ROOT/'policy/ACT'))
+        from detr.act_policy import ACTPolicy
+        from detr.main import get_args_parser
+        p=argparse.ArgumentParser(parents=[get_args_parser()])
+        a=p.parse_args(['--ckpt_dir','/tmp','--policy_class','ACT','--bench_name','aloha','--task_name','aloha','--seed','42','--num_epochs','1','--chunk_size','50'])
+        for k,v in dict(lr=1e-5,lr_backbone=1e-5,backbone='resnet18',enc_layers=4,dec_layers=7,nheads=8,hidden_dim=512,dim_feedforward=3200,camera_names=list(CAMERAS)).items():setattr(a,k,v)
+        self.torch=torch;self.device=torch.device('cuda:0');self.model=ACTPolicy({'kl_weight':10},a)
+        base=Path(os.environ.get('ALOHA_ACT_CHECKPOINT_DIR',str(ROOT/'policy/ACT/checkpoints/aloha_garment_aloha_rgb3')))
+        with (base/'dataset_stats.pkl').open('rb') as f:self.stats=pickle.load(f)
+        self.model.load_state_dict(torch.load(base/'policy_best.ckpt',map_location=self.device,weights_only=True));self.model.eval()
+    def reset(self):pass
+    def __call__(self,obs):
+        images=_images(obs);torch=self.torch
+        x=np.stack([images[k].transpose(2,0,1) for k in CAMERAS]).astype(np.float32)/255
+        q=(obs.qpos-self.stats['qpos_mean'])/self.stats['qpos_std']
+        with torch.inference_mode(): out=self.model(torch.as_tensor(q,device=self.device).float()[None],torch.as_tensor(x,device=self.device)[None]).cpu().numpy()[0]
+        out=out*self.stats['action_std']+self.stats['action_mean']
+        return ActionChunk('joint_position',DT,out,{'policy':'act','execute_steps':50,'observation_steps':1})
+
+class DPAdapter:
+    def __init__(self):
+        import torch,hydra,dill
+        sys.path.insert(0,str(ROOT/'policy/DP'))
+        from omegaconf import OmegaConf
+        OmegaConf.register_new_resolver('eval',eval,replace=True)
+        path=Path(os.environ.get('ALOHA_DP_CHECKPOINT',str(ROOT/'policy/DP/checkpoints/dp-42/10.ckpt')))
+        with path.open('rb') as f: payload=torch.load(f,pickle_module=dill,map_location='cpu',weights_only=False)
+        cfg=payload['cfg'];workspace=hydra.utils.get_class(cfg._target_)(cfg,output_dir=None)
+        workspace.load_payload(payload,exclude_keys=None,include_keys=None)
+        self.model=workspace.ema_model if cfg.training.use_ema else workspace.model
+        self.model.to('cuda:0').eval();self.torch=torch;self.history=deque(maxlen=3)
+    def reset(self):self.history.clear()
+    def __call__(self,obs):
+        import cv2
+        def preprocess(item):
+            images=_images(item)
+            frame={key:cv2.resize(images[src],(320,240),interpolation=cv2.INTER_AREA).transpose(2,0,1).astype(np.float32)/255 for key,src in zip(('head_cam','left_cam','right_cam'),CAMERAS)}
+            frame['agent_pos']=np.asarray(item.qpos,dtype=np.float32).copy()
+            return frame
+        if obs.history:
+            self.history.clear()
+            self.history.extend(preprocess(item) for item in (*obs.history,obs))
+        else:
+            self.history.append(preprocess(obs))
+        frame=self.history[-1]
+        seq=[self.history[0]]*(3-len(self.history))+list(self.history)
+        data={k:self.torch.from_numpy(np.stack([f[k] for f in seq]))[None].to('cuda:0') for k in frame}
+        with self.torch.inference_mode():out=self.model.predict_action(data)['action'][0].detach().cpu().numpy()
+        return ActionChunk('joint_position',DT,out,{'policy':'dp','execute_steps':6,'observation_steps':3})
+
+class Pi05Adapter:
+    def __init__(self):
+        from openpi.training import config
+        from openpi.policies import policy_config
+        ck=Path(os.environ.get('ALOHA_PI05_CHECKPOINT',str(ROOT/'policy/Pi_05/openpi/checkpoints/pi05_aloha_garment_lora/aloha_rgb3_lora/29999')))
+        self.policy=policy_config.create_trained_policy(config.get_config('pi05_aloha_garment_lora'),ck)
+    def reset(self):pass
+    def __call__(self,obs):
+        images=_images(obs)
+        data={'state':np.asarray(obs.qpos,dtype=np.float32),'images':{k:v.transpose(2,0,1) for k,v in images.items()},'prompt':obs.instruction}
+        out=np.asarray(self.policy.infer(data)['actions'],dtype=np.float32)
+        return ActionChunk('joint_position',DT,out,{'policy':'pi05','execute_steps':5,'observation_steps':1})
+
+class HoldAdapter:
+    """Testing only: hold the currently observed 14-D joint position."""
+    def reset(self):pass
+    def __call__(self,obs):
+        _images(obs)
+        return ActionChunk('joint_position',DT,np.asarray(obs.qpos,np.float32)[None])

real_inference/reference/deform_manip_sim/policy/bridge_client.py

@@ -0,0 +1,245 @@
+"""Non-blocking localhost WebSocket client used from Kit's physics loop.
+
+The transport intentionally uses ``websockets.sync.client`` in its dedicated
+thread.  Isaac Sim patches ``asyncio.run`` process-wide for its Kit event
+engine; creating a second asyncio runner from Script Editor can corrupt that
+main loop.  Synchronous I/O is safe here because the worker never touches USD,
+PhysX, or Kit APIs and the physics callback only accesses thread-safe queues.
+"""
+
+from __future__ import annotations
+
+import inspect
+import json
+import queue
+import threading
+import time
+from dataclasses import dataclass
+from typing import Any
+
+from .schema import ActionChunk, Observation, action_chunk_from_wire
+
+
+@dataclass(frozen=True)
+class BridgeStatus:
+    connected: bool
+    request_pending: bool
+    last_error: str | None
+    last_latency_ms: float | None
+    submitted_requests: int
+    received_actions: int
+
+
+class PolicyBridgeClient:
+    """Own all network waits in a daemon thread, never in a PhysX callback.
+
+    The bridge allows only one in-flight observation.  That intentional
+    backpressure keeps a slow policy from accumulating stale camera frames and
+    executing actions for a past cloth state.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        *,
+        response_timeout_s: float = 2.0,
+        reconnect_delay_s: float = 1.0,
+        max_message_bytes: int = 32 * 1024 * 1024,
+    ) -> None:
+        if response_timeout_s <= 0.0 or reconnect_delay_s <= 0.0:
+            raise ValueError("response_timeout_s and reconnect_delay_s must be positive")
+        self.url = str(url)
+        self.response_timeout_s = float(response_timeout_s)
+        self.reconnect_delay_s = float(reconnect_delay_s)
+        self.max_message_bytes = int(max_message_bytes)
+        self._outbound: queue.Queue[tuple[int, Observation, float]] = queue.Queue(maxsize=1)
+        self._inbound: queue.Queue[ActionChunk] = queue.Queue(maxsize=1)
+        self._lock = threading.Lock()
+        self._stop_event = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._websocket: Any | None = None
+        self._next_request_id = 1
+        self._connected = False
+        self._request_pending = False
+        self._last_error: str | None = None
+        self._last_latency_ms: float | None = None
+        self._submitted_requests = 0
+        self._received_actions = 0
+
+    def start(self) -> None:
+        if self._thread is not None and self._thread.is_alive():
+            if self._stop_event.is_set():
+                raise RuntimeError("Policy bridge is still closing; start a new session")
+            return
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._thread_main, name="deform-manip-policy-bridge", daemon=True)
+        self._thread.start()
+
+    def close(self, join_timeout_s: float = 2.0) -> None:
+        self._stop_event.set()
+        # ``recv(timeout=...)`` normally bounds shutdown latency.  Closing the
+        # socket as well wakes a worker currently blocked in a long receive.
+        with self._lock:
+            websocket = self._websocket
+        if websocket is not None:
+            try:
+                if join_timeout_s <= 0:
+                    threading.Thread(target=websocket.close, name="policy-socket-close", daemon=True).start()
+                else:
+                    websocket.close()
+            except Exception:
+                pass
+        thread = self._thread
+        if thread is not None and thread.is_alive():
+            thread.join(timeout=max(0.0, float(join_timeout_s)))
+        if thread is None or not thread.is_alive():
+            self._thread = None
+        with self._lock:
+            self._connected = False
+            self._request_pending = False
+        self._drain(self._outbound)
+        self._drain(self._inbound)
+
+    @staticmethod
+    def _drain(items: queue.Queue[Any]) -> None:
+        while True:
+            try:
+                items.get_nowait()
+            except queue.Empty:
+                return
+
+    def submit(self, observation: Observation) -> bool:
+        """Queue one newest observation, returning false when one is pending."""
+        with self._lock:
+            if self._stop_event.is_set() or self._request_pending:
+                return False
+            request_id = self._next_request_id
+            self._next_request_id += 1
+            self._request_pending = True
+            self._submitted_requests += 1
+        try:
+            self._outbound.put_nowait((request_id, observation, time.monotonic()))
+        except queue.Full:
+            # This should be unreachable because _request_pending was false,
+            # but preserve the invariant if a thread is being shut down.
+            with self._lock:
+                self._request_pending = False
+                self._last_error = "outbound policy queue unexpectedly full"
+            return False
+        return True
+
+    def poll_action(self) -> ActionChunk | None:
+        """Return at most one validated response without blocking Kit."""
+        try:
+            return self._inbound.get_nowait()
+        except queue.Empty:
+            return None
+
+    def status(self) -> BridgeStatus:
+        with self._lock:
+            return BridgeStatus(
+                connected=self._connected,
+                request_pending=self._request_pending,
+                last_error=self._last_error,
+                last_latency_ms=self._last_latency_ms,
+                submitted_requests=self._submitted_requests,
+                received_actions=self._received_actions,
+            )
+
+    def _set_error(self, error: Exception | str) -> None:
+        message = str(error)
+        with self._lock:
+            self._last_error = message
+            self._connected = False
+            self._request_pending = False
+
+    def _thread_main(self) -> None:
+        try:
+            from websockets.sync.client import connect
+        except ImportError as error:
+            self._set_error(
+                "The Kit Python environment needs websockets.sync.client for policy bridging: "
+                f"{error}"
+            )
+            return
+
+        while not self._stop_event.is_set():
+            websocket: Any | None = None
+            try:
+                # ``proxy=None`` is essential on machines with HTTP(S)_PROXY:
+                # websockets >=15 otherwise tries to proxy even 127.0.0.1.
+                # Keep a narrow fallback for old sync-client releases that do
+                # not expose this keyword.
+                connect_kwargs: dict[str, Any] = {
+                    "compression": None,
+                    "max_size": self.max_message_bytes,
+                    "open_timeout": self.response_timeout_s,
+                }
+                try:
+                    if "proxy" in inspect.signature(connect).parameters:
+                        connect_kwargs["proxy"] = None
+                except (TypeError, ValueError):
+                    pass
+                websocket = connect(self.url, **connect_kwargs)
+                with self._lock:
+                    self._websocket = websocket
+                    self._last_error = None
+                # Reset model-specific state (for example a DP observation
+                # deque) once for every newly established connection, before
+                # the first observation is sent. The service's reset response
+                # intentionally has no request_id because it is not an action.
+                websocket.send(json.dumps({"kind": "reset"}, separators=(",", ":")))
+                reset_response = json.loads(websocket.recv(timeout=self.response_timeout_s))
+                if reset_response.get("kind") != "reset" or not reset_response.get("ok", False):
+                    raise RuntimeError(f"Policy reset was rejected: {reset_response}")
+                with self._lock:
+                    self._connected = True
+                self._serve_connection_sync(websocket)
+            except Exception as error:
+                if not self._stop_event.is_set():
+                    self._set_error(error)
+                    # Event.wait is interruptible by close(), unlike sleep().
+                    self._stop_event.wait(self.reconnect_delay_s)
+            finally:
+                if websocket is not None:
+                    try:
+                        websocket.close()
+                    except Exception:
+                        pass
+                with self._lock:
+                    if self._websocket is websocket:
+                        self._websocket = None
+                    self._connected = False
+
+    def _serve_connection_sync(self, websocket: Any) -> None:
+        """Send one request at a time on the worker thread's sync socket."""
+        while not self._stop_event.is_set():
+            try:
+                # A finite queue wait lets ``close()`` join promptly even when
+                # no policy observations are currently being produced.
+                request_id, observation, submitted_at = self._outbound.get(timeout=0.05)
+            except queue.Empty:
+                continue
+            try:
+                websocket.send(json.dumps(observation.to_wire(request_id), separators=(",", ":")))
+                raw_response = websocket.recv(timeout=self.response_timeout_s)
+                response = json.loads(raw_response)
+                if int(response.get("request_id", -1)) != request_id:
+                    raise RuntimeError(
+                        f"Policy response request_id={response.get('request_id')!r} does not match {request_id}"
+                    )
+                action_chunk = action_chunk_from_wire(response)
+                # A full queue contains a less recent policy result.  Drop it:
+                # executing stale cloth actions is worse than skipping one.
+                self._drain(self._inbound)
+                self._inbound.put_nowait(action_chunk)
+                with self._lock:
+                    self._last_latency_ms = (time.monotonic() - submitted_at) * 1000.0
+                    self._received_actions += 1
+                    self._request_pending = False
+                    self._last_error = None
+            except Exception as error:
+                self._set_error(error)
+                # Let the outer loop close and reconnect; a policy process may
+                # have restarted or the server may have rejected a payload.
+                raise

real_inference/reference/deform_manip_sim/policy/schema.py

@@ -0,0 +1,227 @@
+"""Versioned, model-independent policy wire contract.
+
+Images are sent as uncompressed RGB in the first implementation.  Two
+640x480 wrist frames are roughly 1.8 MB per request, which is acceptable for
+a localhost smoke test and avoids adding image-codec dependencies to Kit.
+The ``encoding`` field keeps the protocol extensible to JPEG later.
+"""
+
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+import numpy as np
+
+
+SCHEMA_VERSION = "deform_manip_sim.v1"
+WRIST_CAMERA_NAMES = ("cam_left_wrist", "cam_right_wrist")
+ACTION_DIMS = {
+    "joint_position": 14,
+    # Per arm: world position xyz, orientation [w, x, y, z], gripper openness.
+    "ee_pose": 16,
+    # Per arm: world-frame translation xyz, rotation-vector xyz, gripper openness.
+    "ee_delta": 14,
+}
+
+
+def _float_vector(value: Any, shape: tuple[int, ...], name: str) -> np.ndarray:
+    result = np.asarray(value, dtype=np.float32)
+    if result.shape != shape or not np.isfinite(result).all():
+        raise ValueError(f"{name} must be finite float32 with shape {shape}, got {result.shape}")
+    return result
+
+
+def _rgb_image(value: Any, name: str) -> np.ndarray:
+    if hasattr(value, "detach"):
+        value = value.detach().cpu().numpy()
+    array = np.asarray(value)
+    if array.ndim != 3 or array.shape[2] != 3:
+        raise ValueError(f"{name} must have RGB HWC shape (H, W, 3), got {array.shape}")
+    if array.dtype != np.uint8:
+        # Isaac Sim may provide float RGB in some annotator configurations.
+        # This conversion is explicit and bounded rather than silently sending
+        # an unknown numeric range to the model server.
+        if not np.isfinite(array).all():
+            raise ValueError(f"{name} contains non-finite RGB values")
+        if array.size and float(array.max()) <= 1.0 and float(array.min()) >= 0.0:
+            array = np.rint(array * 255.0)
+        array = np.clip(array, 0, 255).astype(np.uint8)
+    return np.ascontiguousarray(array)
+
+
+def encode_rgb(image: np.ndarray) -> dict[str, Any]:
+    """Encode a HWC uint8 RGB image into JSON-safe raw bytes."""
+    image = _rgb_image(image, "image")
+    return {
+        "encoding": "raw_rgb",
+        "shape": list(image.shape),
+        "data_b64": base64.b64encode(image.tobytes()).decode("ascii"),
+    }
+
+
+def decode_rgb(payload: Mapping[str, Any]) -> np.ndarray:
+    """Decode an image emitted by :func:`encode_rgb` in the policy process."""
+    if payload.get("encoding") != "raw_rgb":
+        raise ValueError(f"Unsupported image encoding {payload.get('encoding')!r}")
+    shape = tuple(int(x) for x in payload.get("shape", ()))
+    if len(shape) != 3 or shape[2] != 3 or min(shape[:2], default=0) <= 0:
+        raise ValueError(f"Invalid raw_rgb shape {shape}")
+    raw = base64.b64decode(payload["data_b64"], validate=True)
+    expected = int(np.prod(shape))
+    if len(raw) != expected:
+        raise ValueError(f"raw_rgb byte count is {len(raw)}, expected {expected} for shape {shape}")
+    return np.frombuffer(raw, dtype=np.uint8).reshape(shape).copy()
+
+
+@dataclass(frozen=True)
+class Observation:
+    """A single wrist-only simulator observation before model preprocessing.
+
+    ``policy_state`` is optional diagnostic input for replaying a recorded
+    training observation while executing its predicted local action from the
+    *current* simulator end-effector pose.  Normal closed-loop simulation
+    leaves it as ``None``: policy adapters then derive their state from
+    ``qpos`` and ``ee_pose`` exactly as before.
+    """
+
+    timestamp_ns: int
+    episode_step: int
+    instruction: str
+    images: Mapping[str, np.ndarray]
+    qpos: np.ndarray
+    ee_pose: np.ndarray
+    policy_state: np.ndarray | None = None
+    history: tuple[Observation, ...] = ()
+
+    def __post_init__(self) -> None:
+        if int(self.timestamp_ns) < 0 or int(self.episode_step) < 0:
+            raise ValueError("timestamp_ns and episode_step must be non-negative")
+        if not isinstance(self.instruction, str):
+            raise TypeError("instruction must be a string")
+        names = set(self.images)
+        required = set(WRIST_CAMERA_NAMES)
+        if names not in (required, required | {"cam_high"}):
+            raise ValueError(f"Observation must have both wrist cameras and optional cam_high, got {sorted(names)}")
+        for name in self.images:
+            _rgb_image(self.images[name], name)
+        _float_vector(self.qpos, (14,), "qpos")
+        _float_vector(self.ee_pose, (14,), "ee_pose")
+        if self.policy_state is not None:
+            _float_vector(self.policy_state, (14,), "policy_state")
+        if len(self.history) > 2:
+            raise ValueError('At most two previous observations are supported')
+        for i, previous in enumerate(self.history):
+            if not isinstance(previous, Observation) or previous.history:
+                raise ValueError('History must contain unnested Observation objects')
+            if previous.episode_step != self.episode_step-len(self.history)+i:
+                raise ValueError('History must contain consecutive previous control steps')
+
+    def to_wire(self, request_id: int) -> dict[str, Any]:
+        """Return a JSON-compatible request accepted by ``serve_policy.py``."""
+        robot = {
+            "qpos": _float_vector(self.qpos, (14,), "qpos").tolist(),
+            "ee_pose": _float_vector(self.ee_pose, (14,), "ee_pose").tolist(),
+        }
+        if self.policy_state is not None:
+            robot["policy_state"] = _float_vector(self.policy_state, (14,), "policy_state").tolist()
+        result = {
+            "kind": "observation",
+            "schema_version": SCHEMA_VERSION,
+            "request_id": int(request_id),
+            "observation": {
+                "timestamp_ns": int(self.timestamp_ns),
+                "episode_step": int(self.episode_step),
+                "instruction": self.instruction,
+                "images": {name: encode_rgb(image) for name, image in self.images.items()},
+                "robot": robot,
+            },
+        }
+        if self.history:
+            result['observation']['history'] = [item.to_wire(0)['observation'] for item in self.history]
+        return result
+
+
+def observation_from_wire(payload: Mapping[str, Any]) -> Observation:
+    """Decode a wire observation in the external policy process."""
+    if payload.get("schema_version") != SCHEMA_VERSION:
+        raise ValueError(f"Unsupported schema version {payload.get('schema_version')!r}")
+    data = payload["observation"]
+    images = {name: decode_rgb(image) for name, image in data["images"].items()}
+    robot = data["robot"]
+    return Observation(
+        timestamp_ns=int(data["timestamp_ns"]),
+        episode_step=int(data["episode_step"]),
+        instruction=str(data["instruction"]),
+        images=images,
+        qpos=np.asarray(robot["qpos"], dtype=np.float32),
+        ee_pose=np.asarray(robot["ee_pose"], dtype=np.float32),
+        policy_state=(
+            np.asarray(robot["policy_state"], dtype=np.float32) if robot.get("policy_state") is not None else None
+        ),
+        history=tuple(observation_from_wire({'schema_version': SCHEMA_VERSION, 'observation': item})
+                      for item in data.get('history', ())),
+    )
+
+
+@dataclass(frozen=True)
+class ActionChunk:
+    """A time-ordered sequence of canonical robot commands."""
+
+    action_type: str
+    dt: float
+    actions: np.ndarray
+    # Optional, JSON-safe evidence emitted by an external adapter.  It is
+    # never interpreted by PhysX; dataset-input diagnostics use it to retain
+    # the model-space action before coordinate conversion.
+    diagnostics: Mapping[str, Any] | None = None
+
+    def __post_init__(self) -> None:
+        if self.action_type not in ACTION_DIMS:
+            raise ValueError(f"Unsupported action_type {self.action_type!r}; expected one of {sorted(ACTION_DIMS)}")
+        if not np.isfinite(self.dt) or float(self.dt) <= 0.0:
+            raise ValueError(f"ActionChunk dt must be positive and finite, got {self.dt!r}")
+        actions = np.asarray(self.actions, dtype=np.float32)
+        if actions.ndim == 1:
+            actions = actions[None, :]
+        expected = ACTION_DIMS[self.action_type]
+        if actions.ndim != 2 or actions.shape[0] == 0 or actions.shape[1] != expected or not np.isfinite(actions).all():
+            raise ValueError(
+                f"{self.action_type} actions must be finite shape (horizon, {expected}), got {actions.shape}"
+            )
+        object.__setattr__(self, "actions", np.ascontiguousarray(actions))
+        if self.diagnostics is not None and not isinstance(self.diagnostics, Mapping):
+            raise TypeError("ActionChunk diagnostics must be a mapping when provided")
+        if self.diagnostics is not None:
+            object.__setattr__(self, "diagnostics", dict(self.diagnostics))
+
+    def to_wire(self, request_id: int) -> dict[str, Any]:
+        action = {
+            "action_type": self.action_type,
+            "dt": float(self.dt),
+            "actions": self.actions.tolist(),
+        }
+        if self.diagnostics is not None:
+            action["diagnostics"] = dict(self.diagnostics)
+        return {
+            "kind": "action",
+            "schema_version": SCHEMA_VERSION,
+            "request_id": int(request_id),
+            "action": action,
+        }
+
+
+def action_chunk_from_wire(payload: Mapping[str, Any]) -> ActionChunk:
+    """Decode and validate a policy response before it reaches PhysX."""
+    if payload.get("schema_version") != SCHEMA_VERSION:
+        raise ValueError(f"Unsupported schema version {payload.get('schema_version')!r}")
+    if payload.get("kind") != "action":
+        raise ValueError(f"Expected policy response kind='action', got {payload.get('kind')!r}")
+    action = payload["action"]
+    return ActionChunk(
+        action_type=str(action["action_type"]),
+        dt=float(action["dt"]),
+        actions=np.asarray(action["actions"], dtype=np.float32),
+        diagnostics=action.get("diagnostics"),
+    )

real_inference/reference/scripts/serve_policy.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""Serve a canonical policy over localhost WebSocket.
+
+This file intentionally does not contain DP or pi0.5 dependencies.  Use the
+mock modes to validate DeformManipSim end-to-end, then pass ``--adapter`` to
+load a callable from the Python environment that owns a real checkpoint.
+
+Adapter contract::
+
+    def adapter(observation: Observation) -> ActionChunk | dict:
+        ...
+
+The returned dict must have ``action_type``, ``dt`` and ``actions`` fields.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import importlib
+import json
+import sys
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+import numpy as np
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from deform_manip_sim.policy.schema import ActionChunk, Observation, action_chunk_from_wire, observation_from_wire
+
+
+def _chunk(action_type: str, dt: float, actions: Any) -> ActionChunk:
+    return ActionChunk(action_type=action_type, dt=dt, actions=np.asarray(actions, dtype=np.float32))
+
+
+def hold_policy(observation: Observation) -> ActionChunk:
+    """Echo qpos as a safe 14-D joint-position command."""
+    return _chunk("joint_position", 0.1, observation.qpos[None, :])
+
+
+def joint_demo_policy(observation: Observation) -> ActionChunk:
+    """Small, reversible left-joint motion for bridge smoke testing only."""
+    action = observation.qpos.copy()
+    phase = (observation.episode_step % 40) / 39.0
+    action[1] = np.float32(0.15 * np.sin(2.0 * np.pi * phase))
+    action[8] = np.float32(-0.15 * np.sin(2.0 * np.pi * phase))
+    return _chunk("joint_position", 0.1, action[None, :])
+
+
+def ee_demo_policy(observation: Observation) -> ActionChunk:
+    """Return the current commanded Cartesian poses without moving them."""
+    action = np.empty(16, dtype=np.float32)
+    action[0:7] = observation.ee_pose[0:7]
+    action[7] = observation.qpos[6]
+    action[8:15] = observation.ee_pose[7:14]
+    action[15] = observation.qpos[13]
+    return _chunk("ee_pose", 0.1, action[None, :])
+
+
+def _load_adapter(spec: str) -> Callable[[Observation], ActionChunk]:
+    if ":" not in spec:
+        raise ValueError("--adapter must have MODULE:ATTRIBUTE form")
+    module_name, attribute_name = spec.split(":", 1)
+    obj = getattr(importlib.import_module(module_name), attribute_name)
+    # Accept either a function or a no-argument adapter class/instance.
+    adapter = obj() if isinstance(obj, type) else obj
+    if not callable(adapter):
+        raise TypeError(f"Adapter {spec!r} is not callable")
+
+    def call(observation: Observation) -> ActionChunk:
+        output = adapter(observation)
+        if isinstance(output, ActionChunk):
+            return output
+        if isinstance(output, dict):
+            return ActionChunk(
+                action_type=str(output["action_type"]),
+                dt=float(output["dt"]),
+                actions=np.asarray(output["actions"], dtype=np.float32),
+            )
+        raise TypeError(f"Adapter {spec!r} returned {type(output)}, not ActionChunk or dict")
+
+    # Preserve the optional reset hook on the wrapper. It is needed by DP
+    # adapters that maintain image/state history, while remaining a no-op for
+    # stateless policies such as the current Pi0.5 adapter.
+    reset = getattr(adapter, "reset", None)
+    if callable(reset):
+        setattr(call, "reset", reset)
+    return call
+
+
+async def _serve(host: str, port: int, policy: Callable[[Observation], ActionChunk]) -> None:
+    try:
+        import websockets
+    except ImportError as error:
+        raise RuntimeError("Install websockets in the policy environment: pip install websockets") from error
+
+    async def handler(websocket: Any, *_unused_path: Any) -> None:
+        async for raw_request in websocket:
+            try:
+                request = json.loads(raw_request)
+                if request.get("kind") == "health":
+                    await websocket.send(json.dumps({"kind": "health", "ok": True}))
+                    continue
+                if request.get("kind") == "reset":
+                    reset = getattr(policy, "reset", None)
+                    if callable(reset):
+                        reset()
+                    await websocket.send(json.dumps({"kind": "reset", "ok": True}))
+                    continue
+                observation = observation_from_wire(request)
+                started = time.perf_counter()
+                chunk = policy(observation)
+                elapsed_ms = (time.perf_counter() - started) * 1000.0
+                response = chunk.to_wire(int(request["request_id"]))
+                response['action'].setdefault('diagnostics', {})['server_inference_ms'] = elapsed_ms
+                await websocket.send(json.dumps(response, separators=(",", ":")))
+            except Exception as error:
+                error_response = {
+                    "kind": "error",
+                    "request_id": request.get("request_id") if "request" in locals() else None,
+                    "error": f"{type(error).__name__}: {error}",
+                }
+                await websocket.send(json.dumps(error_response, separators=(",", ":")))
+
+    print(f"[DeformManipSim] policy server listening at ws://{host}:{port}", flush=True)
+    async with websockets.serve(handler, host, port, max_size=32 * 1024 * 1024):
+        await asyncio.Future()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8765)
+    parser.add_argument("--mock", choices=("hold", "joint_demo", "ee_demo"), default="ee_demo")
+    parser.add_argument("--adapter", help="Real policy callable in MODULE:ATTRIBUTE form; overrides --mock")
+    args = parser.parse_args()
+    if args.adapter:
+        policy = _load_adapter(args.adapter)
+        print(f"[DeformManipSim] loaded external policy adapter {args.adapter}", flush=True)
+    else:
+        policy = {"hold": hold_policy, "joint_demo": joint_demo_policy, "ee_demo": ee_demo_policy}[args.mock]
+        print(f"[DeformManipSim] using mock policy {args.mock}", flush=True)
+    try:
+        asyncio.run(_serve(args.host, args.port, policy))
+    except KeyboardInterrupt:
+        print("\n[DeformManipSim] policy server stopped", flush=True)
+
+
+if __name__ == "__main__":
+    main()

real_inference/source/XPolicyLab/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

real_inference/source/XPolicyLab/policy/Pi_05/openpi/.python-version

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

real_inference/source/XPolicyLab/policy/Pi_05/openpi/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

real_inference/source/XPolicyLab/policy/Pi_05/openpi/LICENSE_GEMMA.txt

@@ -0,0 +1,77 @@
+Gemma Terms of Use 
+
+Last modified: February 21, 2024
+
+By using, reproducing, modifying, distributing, performing or displaying any portion or element of Gemma, Model Derivatives including via any Hosted Service, (each as defined below) (collectively, the "Gemma Services") or otherwise accepting the terms of this Agreement, you agree to be bound by this Agreement.
+
+Section 1: DEFINITIONS
+1.1 Definitions
+(a) "Agreement" or "Gemma Terms of Use" means these terms and conditions that govern the use, reproduction, Distribution or modification of the Gemma Services and any terms and conditions incorporated by reference.
+
+(b) "Distribution" or "Distribute" means any transmission, publication, or other sharing of Gemma or Model Derivatives to a third party, including by providing or making Gemma or its functionality available as a hosted service via API, web access, or any other electronic or remote means ("Hosted Service").
+
+(c) "Gemma" means the set of machine learning language models, trained model weights and parameters identified at ai.google.dev/gemma, regardless of the source that you obtained it from.
+
+(d) "Google" means Google LLC.
+
+(e) "Model Derivatives" means all (i) modifications to Gemma, (ii) works based on Gemma, or (iii) any other machine learning model which is created by transfer of patterns of the weights, parameters, operations, or Output of Gemma, to that model in order to cause that model to perform similarly to Gemma, including distillation methods that use intermediate data representations or methods based on the generation of synthetic data Outputs by Gemma for training that model. For clarity, Outputs are not deemed Model Derivatives.
+
+(f) "Output" means the information content output of Gemma or a Model Derivative that results from operating or otherwise using Gemma or the Model Derivative, including via a Hosted Service.
+
+1.2
+As used in this Agreement, "including" means "including without limitation".
+
+Section 2: ELIGIBILITY AND USAGE
+2.1 Eligibility
+You represent and warrant that you have the legal capacity to enter into this Agreement (including being of sufficient age of consent). If you are accessing or using any of the Gemma Services for or on behalf of a legal entity, (a) you are entering into this Agreement on behalf of yourself and that legal entity, (b) you represent and warrant that you have the authority to act on behalf of and bind that entity to this Agreement and (c) references to "you" or "your" in the remainder of this Agreement refers to both you (as an individual) and that entity.
+
+2.2 Use
+You may use, reproduce, modify, Distribute, perform or display any of the Gemma Services only in accordance with the terms of this Agreement, and must not violate (or encourage or permit anyone else to violate) any term of this Agreement.
+
+Section 3: DISTRIBUTION AND RESTRICTIONS
+3.1 Distribution and Redistribution
+You may reproduce or Distribute copies of Gemma or Model Derivatives if you meet all of the following conditions:
+
+You must include the use restrictions referenced in Section 3.2 as an enforceable provision in any agreement (e.g., license agreement, terms of use, etc.) governing the use and/or distribution of Gemma or Model Derivatives and you must provide notice to subsequent users you Distribute to that Gemma or Model Derivatives are subject to the use restrictions in Section 3.2.
+You must provide all third party recipients of Gemma or Model Derivatives a copy of this Agreement.
+You must cause any modified files to carry prominent notices stating that you modified the files.
+All Distributions (other than through a Hosted Service) must be accompanied by a "Notice" text file that contains the following notice: "Gemma is provided under and subject to the Gemma Terms of Use found at ai.google.dev/gemma/terms".
+You may add your own intellectual property statement to your modifications and, except as set forth in this Section, may provide additional or different terms and conditions for use, reproduction, or Distribution of your modifications, or for any such Model Derivatives as a whole, provided your use, reproduction, modification, Distribution, performance, and display of Gemma otherwise complies with the terms and conditions of this Agreement. Any additional or different terms and conditions you impose must not conflict with the terms of this Agreement.
+
+3.2 Use Restrictions
+You must not use any of the Gemma Services:
+
+for the restricted uses set forth in the Gemma Prohibited Use Policy at ai.google.dev/gemma/prohibited_use_policy ("Prohibited Use Policy"), which is hereby incorporated by reference into this Agreement; or
+in violation of applicable laws and regulations.
+To the maximum extent permitted by law, Google reserves the right to restrict (remotely or otherwise) usage of any of the Gemma Services that Google reasonably believes are in violation of this Agreement.
+
+3.3 Generated Output
+Google claims no rights in Outputs you generate using Gemma. You and your users are solely responsible for Outputs and their subsequent uses.
+
+Section 4: ADDITIONAL PROVISIONS
+4.1 Updates
+Google may update Gemma from time to time, and you must make reasonable efforts to use the latest version of Gemma.
+
+4.2 Trademarks
+Nothing in this Agreement grants you any rights to use Google's trademarks, trade names, logos or to otherwise suggest endorsement or misrepresent the relationship between you and Google. Google reserves any rights not expressly granted herein.
+
+4.3 DISCLAIMER OF WARRANTY
+UNLESS REQUIRED BY APPLICABLE LAW, THE GEMMA SERVICES, AND OUTPUTS, ARE PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING, REPRODUCING, MODIFYING, PERFORMING, DISPLAYING OR OR DISTRIBUTING ANY OF THE GEMMA SERVICES OR OUTPUTS AND ASSUME ANY AND ALL RISKS ASSOCIATED WITH YOUR USE OR DISTRIBUTION OF ANY OF THE GEMMA SERVICES OR OUTPUTS AND YOUR EXERCISE OF RIGHTS AND PERMISSIONS UNDER THIS AGREEMENT.
+
+4.4 LIMITATION OF LIABILITY
+TO THE FULLEST EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY, CONTRACT, OR OTHERWISE, UNLESS REQUIRED BY APPLICABLE LAW, SHALL GOOGLE OR ITS AFFILIATES BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, EXEMPLARY, CONSEQUENTIAL, OR PUNITIVE DAMAGES, OR LOST PROFITS OF ANY KIND ARISING FROM THIS AGREEMENT OR RELATED TO, ANY OF THE GEMMA SERVICES OR OUTPUTS EVEN IF GOOGLE OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+4.5 Term, Termination, and Survival
+The term of this Agreement will commence upon your acceptance of this Agreement (including acceptance by your use, modification, or Distribution, reproduction, performance or display of any portion or element of the Gemma Services) and will continue in full force and effect until terminated in accordance with the terms of this Agreement. Google may terminate this Agreement if you are in breach of any term of this Agreement. Upon termination of this Agreement, you must delete and cease use and Distribution of all copies of Gemma and Model Derivatives in your possession or control. Sections 1, 2.1, 3.3, 4.2 to 4.9 shall survive the termination of this Agreement.
+
+4.6 Governing Law and Jurisdiction
+This Agreement will be governed by the laws of the State of California without regard to choice of law principles. The UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement. The state and federal courts of Santa Clara County, California shall have exclusive jurisdiction of any dispute arising out of this Agreement.
+
+4.7 Severability
+If any provision of this Agreement is held to be invalid, illegal or unenforceable, the remaining provisions shall be unaffected thereby and remain valid as if such provision had not been set forth herein.
+
+4.8 Entire Agreement
+This Agreement states all the terms agreed between the parties and supersedes all other agreements between the parties as of the date of acceptance relating to its subject matter.
+
+4.9 No Waiver
+Google will not be treated as having waived any rights by not exercising (or delaying the exercise of) any rights under this Agreement.

real_inference/source/XPolicyLab/policy/Pi_05/openpi/README.md

@@ -0,0 +1,323 @@
+# openpi
+
+openpi holds open-source models and packages for robotics, published by the [Physical Intelligence team](https://www.physicalintelligence.company/).
+
+Currently, this repo contains three types of models:
+- the [π₀ model](https://www.physicalintelligence.company/blog/pi0), a flow-based vision-language-action model (VLA).
+- the [π₀-FAST model](https://www.physicalintelligence.company/research/fast), an autoregressive VLA, based on the FAST action tokenizer.
+- the [π₀.₅ model](https://www.physicalintelligence.company/blog/pi05), an upgraded version of π₀ with better open-world generalization trained with [knowledge insulation](https://www.physicalintelligence.company/research/knowledge_insulation). Note that, in this repository, we currently only support the flow matching head for both $\pi_{0.5}$ training and inference.
+
+For all models, we provide _base model_ checkpoints, pre-trained on 10k+ hours of robot data, and examples for using them out of the box or fine-tuning them to your own datasets.
+
+This is an experiment: $\pi_0$ was developed for our own robots, which differ from the widely used platforms such as [ALOHA](https://tonyzhaozh.github.io/aloha/) and [DROID](https://droid-dataset.github.io/), and though we are optimistic that researchers and practitioners will be able to run creative new experiments adapting $\pi_0$ to their own platforms, we do not expect every such attempt to be successful. All this is to say: $\pi_0$ may or may not work for you, but you are welcome to try it and see!
+
+## Updates
+
+- [Sept 2025] We released PyTorch support in openpi.
+- [Sept 2025] We released pi05, an upgraded version of pi0 with better open-world generalization.
+- [Sept 2025]: We have added an [improved idle filter](examples/droid/README_train.md#data-filtering) for DROID training.
+- [Jun 2025]: We have added [instructions](examples/droid/README_train.md) for using `openpi` to train VLAs on the full [DROID dataset](https://droid-dataset.github.io/). This is an approximate open-source implementation of the training pipeline used to train pi0-FAST-DROID. 
+
+
+## Requirements
+
+To run the models in this repository, you will need an NVIDIA GPU with at least the following specifications. These estimations assume a single GPU, but you can also use multiple GPUs with model parallelism to reduce per-GPU memory requirements by configuring `fsdp_devices` in the training config. Please also note that the current training script does not yet support multi-node training.
+
+| Mode               | Memory Required | Example GPU        |
+| ------------------ | --------------- | ------------------ |
+| Inference          | > 8 GB          | RTX 4090           |
+| Fine-Tuning (LoRA) | > 22.5 GB       | RTX 4090           |
+| Fine-Tuning (Full) | > 70 GB         | A100 (80GB) / H100 |
+
+The repo has been tested with Ubuntu 22.04, we do not currently support other operating systems.
+
+## Installation
+
+When cloning this repo, make sure to update submodules:
+
+```bash
+git clone --recurse-submodules git@github.com:Physical-Intelligence/openpi.git
+
+# Or if you already cloned the repo:
+git submodule update --init --recursive
+```
+
+We use [uv](https://docs.astral.sh/uv/) to manage Python dependencies. See the [uv installation instructions](https://docs.astral.sh/uv/getting-started/installation/) to set it up. Once uv is installed, run the following to set up the environment:
+
+```bash
+GIT_LFS_SKIP_SMUDGE=1 uv sync
+GIT_LFS_SKIP_SMUDGE=1 uv pip install -e .
+```
+
+NOTE: `GIT_LFS_SKIP_SMUDGE=1` is needed to pull LeRobot as a dependency.
+
+**Docker**: As an alternative to uv installation, we provide instructions for installing openpi using Docker. If you encounter issues with your system setup, consider using Docker to simplify installation. See [Docker Setup](docs/docker.md) for more details.
+
+
+
+
+## Model Checkpoints
+
+### Base Models
+We provide multiple base VLA model checkpoints. These checkpoints have been pre-trained on 10k+ hours of robot data, and can be used for fine-tuning.
+
+| Model        | Use Case    | Description                                                                                                 | Checkpoint Path                                |
+| ------------ | ----------- | ----------------------------------------------------------------------------------------------------------- | ---------------------------------------------- |
+| $\pi_0$      | Fine-Tuning | Base [π₀ model](https://www.physicalintelligence.company/blog/pi0) for fine-tuning                | `gs://openpi-assets/checkpoints/pi0_base`      |
+| $\pi_0$-FAST | Fine-Tuning | Base autoregressive [π₀-FAST model](https://www.physicalintelligence.company/research/fast) for fine-tuning | `gs://openpi-assets/checkpoints/pi0_fast_base` |
+| $\pi_{0.5}$    | Fine-Tuning | Base [π₀.₅ model](https://www.physicalintelligence.company/blog/pi05) for fine-tuning    | `gs://openpi-assets/checkpoints/pi05_base`      |
+
+### Fine-Tuned Models
+We also provide "expert" checkpoints for various robot platforms and tasks. These models are fine-tuned from the base models above and intended to run directly on the target robot. These may or may not work on your particular robot. Since these checkpoints were fine-tuned on relatively small datasets collected with more widely available robots, such as ALOHA and the DROID Franka setup, they might not generalize to your particular setup, though we found some of these, especially the DROID checkpoint, to generalize quite broadly in practice.
+
+| Model                    | Use Case    | Description                                                                                                                                                                                              | Checkpoint Path                                       |
+| ------------------------ | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
+| $\pi_0$-FAST-DROID       | Inference   | $\pi_0$-FAST model fine-tuned on the [DROID dataset](https://droid-dataset.github.io/): can perform a wide range of simple table-top manipulation tasks 0-shot in new scenes on the DROID robot platform | `gs://openpi-assets/checkpoints/pi0_fast_droid`       |
+| $\pi_0$-DROID            | Fine-Tuning | $\pi_0$ model fine-tuned on the [DROID dataset](https://droid-dataset.github.io/): faster inference than $\pi_0$-FAST-DROID, but may not follow language commands as well                                | `gs://openpi-assets/checkpoints/pi0_droid`            |
+| $\pi_0$-ALOHA-towel      | Inference   | $\pi_0$ model fine-tuned on internal [ALOHA](https://tonyzhaozh.github.io/aloha/) data: can fold diverse towels 0-shot on ALOHA robot platforms                                                          | `gs://openpi-assets/checkpoints/pi0_aloha_towel`      |
+| $\pi_0$-ALOHA-tupperware | Inference   | $\pi_0$ model fine-tuned on internal [ALOHA](https://tonyzhaozh.github.io/aloha/) data: can unpack food from a tupperware container                                                                                                             | `gs://openpi-assets/checkpoints/pi0_aloha_tupperware` |
+| $\pi_0$-ALOHA-pen-uncap  | Inference   | $\pi_0$ model fine-tuned on public [ALOHA](https://dit-policy.github.io/) data: can uncap a pen                                                                                                          | `gs://openpi-assets/checkpoints/pi0_aloha_pen_uncap`  |
+| $\pi_{0.5}$-LIBERO      | Inference   | $\pi_{0.5}$ model fine-tuned for the [LIBERO](https://libero-project.github.io/datasets) benchmark: gets state-of-the-art performance (see [LIBERO README](examples/libero/README.md)) | `gs://openpi-assets/checkpoints/pi05_libero`      |
+| $\pi_{0.5}$-DROID      | Inference / Fine-Tuning | $\pi_{0.5}$ model fine-tuned on the [DROID dataset](https://droid-dataset.github.io/) with [knowledge insulation](https://www.physicalintelligence.company/research/knowledge_insulation): fast inference and good language-following | `gs://openpi-assets/checkpoints/pi05_droid`      |
+
+
+By default, checkpoints are automatically downloaded from `gs://openpi-assets` and are cached in `~/.cache/openpi` when needed. You can overwrite the download path by setting the `OPENPI_DATA_HOME` environment variable.
+
+
+
+
+## Running Inference for a Pre-Trained Model
+
+Our pre-trained model checkpoints can be run with a few lines of code (here our $\pi_0$-FAST-DROID model):
+```python
+from openpi.training import config as _config
+from openpi.policies import policy_config
+from openpi.shared import download
+
+config = _config.get_config("pi05_droid")
+checkpoint_dir = download.maybe_download("gs://openpi-assets/checkpoints/pi05_droid")
+
+# Create a trained policy.
+policy = policy_config.create_trained_policy(config, checkpoint_dir)
+
+# Run inference on a dummy example.
+example = {
+    "observation/exterior_image_1_left": ...,
+    "observation/wrist_image_left": ...,
+    ...
+    "prompt": "pick up the fork"
+}
+action_chunk = policy.infer(example)["actions"]
+```
+You can also test this out in the [example notebook](examples/inference.ipynb).
+
+We provide detailed step-by-step examples for running inference of our pre-trained checkpoints on [DROID](examples/droid/README.md) and [ALOHA](examples/aloha_real/README.md) robots.
+
+**Remote Inference**: We provide [examples and code](docs/remote_inference.md) for running inference of our models **remotely**: the model can run on a different server and stream actions to the robot via a websocket connection. This makes it easy to use more powerful GPUs off-robot and keep robot and policy environments separate.
+
+**Test inference without a robot**: We provide a [script](examples/simple_client/README.md) for testing inference without a robot. This script will generate a random observation and run inference with the model. See [here](examples/simple_client/README.md) for more details.
+
+
+
+
+
+## Fine-Tuning Base Models on Your Own Data
+
+We will fine-tune the $\pi_{0.5}$ model on the [LIBERO dataset](https://libero-project.github.io/datasets) as a running example for how to fine-tune a base model on your own data. We will explain three steps:
+1. Convert your data to a LeRobot dataset (which we use for training)
+2. Defining training configs and running training
+3. Spinning up a policy server and running inference
+
+### 1. Convert your data to a LeRobot dataset
+
+We provide a minimal example script for converting LIBERO data to a LeRobot dataset in [`examples/libero/convert_libero_data_to_lerobot.py`](examples/libero/convert_libero_data_to_lerobot.py). You can easily modify it to convert your own data! You can download the raw LIBERO dataset from [here](https://huggingface.co/datasets/openvla/modified_libero_rlds), and run the script with:
+
+```bash
+uv run examples/libero/convert_libero_data_to_lerobot.py --data_dir /path/to/your/libero/data
+```
+
+**Note:** If you just want to fine-tune on LIBERO, you can skip this step, because our LIBERO fine-tuning configs point to a pre-converted LIBERO dataset. This step is merely an example that you can adapt to your own data.
+
+### 2. Defining training configs and running training
+
+To fine-tune a base model on your own data, you need to define configs for data processing and training. We provide example configs with detailed comments for LIBERO below, which you can modify for your own dataset:
+
+- [`LiberoInputs` and `LiberoOutputs`](src/openpi/policies/libero_policy.py): Defines the data mapping from the LIBERO environment to the model and vice versa. Will be used for both, training and inference.
+- [`LeRobotLiberoDataConfig`](src/openpi/training/config.py): Defines how to process raw LIBERO data from LeRobot dataset for training.
+- [`TrainConfig`](src/openpi/training/config.py): Defines fine-tuning hyperparameters, data config, and weight loader.
+
+We provide example fine-tuning configs for [π₀](src/openpi/training/config.py), [π₀-FAST](src/openpi/training/config.py), and [π₀.₅](src/openpi/training/config.py) on LIBERO data.
+
+Before we can run training, we need to compute the normalization statistics for the training data. Run the script below with the name of your training config:
+
+```bash
+uv run scripts/compute_norm_stats.py --config-name pi05_libero
+```
+
+Now we can kick off training with the following command (the `--overwrite` flag is used to overwrite existing checkpoints if you rerun fine-tuning with the same config):
+
+```bash
+XLA_PYTHON_CLIENT_MEM_FRACTION=0.9 uv run scripts/train.py pi05_libero --exp-name=my_experiment --overwrite
+```
+
+The command will log training progress to the console and save checkpoints to the `checkpoints` directory. You can also monitor training progress on the Weights & Biases dashboard. For maximally using the GPU memory, set `XLA_PYTHON_CLIENT_MEM_FRACTION=0.9` before running training -- this enables JAX to use up to 90% of the GPU memory (vs. the default of 75%).
+
+**Note:** We provide functionality for *reloading* normalization statistics for state / action normalization from pre-training. This can be beneficial if you are fine-tuning to a new task on a robot that was part of our pre-training mixture. For more details on how to reload normalization statistics, see the [norm_stats.md](docs/norm_stats.md) file.
+
+### 3. Spinning up a policy server and running inference
+
+Once training is complete, we can run inference by spinning up a policy server and then querying it from a LIBERO evaluation script. Launching a model server is easy (we use the checkpoint for iteration 20,000 for this example, modify as needed):
+
+```bash
+uv run scripts/serve_policy.py policy:checkpoint --policy.config=pi05_libero --policy.dir=checkpoints/pi05_libero/my_experiment/20000
+```
+
+This will spin up a server that listens on port 8000 and waits for observations to be sent to it. We can then run an evaluation script (or robot runtime) that queries the server.
+
+For running the LIBERO eval in particular, we provide (and recommend using) a Dockerized workflow that handles both the policy server and the evaluation script together. See the [LIBERO README](examples/libero/README.md) for more details.
+
+If you want to embed a policy server call in your own robot runtime, we have a minimal example of how to do so in the [remote inference docs](docs/remote_inference.md).
+
+
+
+### More Examples
+
+We provide more examples for how to fine-tune and run inference with our models on the ALOHA platform in the following READMEs:
+- [ALOHA Simulator](examples/aloha_sim)
+- [ALOHA Real](examples/aloha_real)
+- [UR5](examples/ur5)
+
+## PyTorch Support
+
+openpi now provides PyTorch implementations of π₀ and π₀.₅ models alongside the original JAX versions! The PyTorch implementation has been validated on the LIBERO benchmark (both inference and finetuning). A few features are currently not supported (this may change in the future):
+
+- The π₀-FAST model
+- Mixed precision training
+- FSDP (fully-sharded data parallelism) training
+- LoRA (low-rank adaptation) training
+- EMA (exponential moving average) weights during training
+
+### Setup
+1. Make sure that you have the latest version of all dependencies installed: `uv sync`
+
+2. Double check that you have transformers 4.53.2 installed: `uv pip show transformers`
+
+3. Apply the transformers library patches:
+   ```bash
+   cp -r ./src/openpi/models_pytorch/transformers_replace/* .venv/lib/python3.11/site-packages/transformers/
+   ```
+
+This overwrites several files in the transformers library with necessary model changes: 1) supporting AdaRMS, 2) correctly controlling the precision of activations, and 3) allowing the KV cache to be used without being updated.
+
+**WARNING**: With the default uv link mode (hardlink), this will permanently affect the transformers library in your uv cache, meaning the changes will survive reinstallations of transformers and could even propagate to other projects that use transformers. To fully undo this operation, you must run `uv cache clean transformers`.
+
+### Converting JAX Models to PyTorch
+
+To convert a JAX model checkpoint to PyTorch format:
+
+```bash
+uv run examples/convert_jax_model_to_pytorch.py \
+    --checkpoint_dir /path/to/jax/checkpoint \
+    --config_name <config name> \
+    --output_path /path/to/converted/pytorch/checkpoint
+```
+
+### Running Inference with PyTorch
+
+The PyTorch implementation uses the same API as the JAX version - you only need to change the checkpoint path to point to the converted PyTorch model:
+
+```python
+from openpi.training import config as _config
+from openpi.policies import policy_config
+from openpi.shared import download
+
+config = _config.get_config("pi05_droid")
+checkpoint_dir = "/path/to/converted/pytorch/checkpoint"
+
+# Create a trained policy (automatically detects PyTorch format)
+policy = policy_config.create_trained_policy(config, checkpoint_dir)
+
+# Run inference (same API as JAX)
+action_chunk = policy.infer(example)["actions"]
+```
+
+### Policy Server with PyTorch
+
+The policy server works identically with PyTorch models - just point to the converted checkpoint directory:
+
+```bash
+uv run scripts/serve_policy.py policy:checkpoint \
+    --policy.config=pi05_droid \
+    --policy.dir=/path/to/converted/pytorch/checkpoint
+```
+
+### Finetuning with PyTorch
+
+To finetune a model in PyTorch:
+
+1. Convert the JAX base model to PyTorch format:
+   ```bash
+   uv run examples/convert_jax_model_to_pytorch.py \
+       --config_name <config name> \
+       --checkpoint_dir /path/to/jax/base/model \
+       --output_path /path/to/pytorch/base/model
+   ```
+
+2. Specify the converted PyTorch model path in your config using `pytorch_weight_path`
+
+3. Launch training using one of these modes:
+
+```bash
+# Single GPU training:
+uv run scripts/train_pytorch.py <config_name> --exp_name <run_name> --save_interval <interval>
+
+# Example:
+uv run scripts/train_pytorch.py debug --exp_name pytorch_test
+uv run scripts/train_pytorch.py debug --exp_name pytorch_test --resume  # Resume from latest checkpoint
+
+# Multi-GPU training (single node):
+uv run torchrun --standalone --nnodes=1 --nproc_per_node=<num_gpus> scripts/train_pytorch.py <config_name> --exp_name <run_name>
+
+# Example:
+uv run torchrun --standalone --nnodes=1 --nproc_per_node=2 scripts/train_pytorch.py pi0_aloha_sim --exp_name pytorch_ddp_test
+uv run torchrun --standalone --nnodes=1 --nproc_per_node=2 scripts/train_pytorch.py pi0_aloha_sim --exp_name pytorch_ddp_test --resume
+
+# Multi-Node Training:
+uv run torchrun \
+    --nnodes=<num_nodes> \
+    --nproc_per_node=<gpus_per_node> \
+    --node_rank=<rank_of_node> \
+    --master_addr=<master_ip> \
+    --master_port=<port> \
+    scripts/train_pytorch.py <config_name> --exp_name=<run_name> --save_interval <interval>
+```
+
+### Precision Settings
+
+JAX and PyTorch implementations handle precision as follows:
+
+**JAX:**
+1. Inference: most weights and computations in bfloat16, with a few computations in float32 for stability
+2. Training: defaults to mixed precision: weights and gradients in float32, (most) activations and computations in bfloat16. You can change to full float32 training by setting `dtype` to float32 in the config.
+
+**PyTorch:**
+1. Inference: matches JAX -- most weights and computations in bfloat16, with a few weights converted to float32 for stability
+2. Training: supports either full bfloat16 (default) or full float32. You can change it by setting `pytorch_training_precision` in the config. bfloat16 uses less memory but exhibits higher losses compared to float32. Mixed precision is not yet supported.
+
+With torch.compile, inference speed is comparable between JAX and PyTorch.
+
+## Troubleshooting
+
+We will collect common issues and their solutions here. If you encounter an issue, please check here first. If you can't find a solution, please file an issue on the repo (see [here](CONTRIBUTING.md) for guidelines).
+
+| Issue                                     | Resolution                                                                                                                                                                                   |
+| ----------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `uv sync` fails with dependency conflicts | Try removing the virtual environment directory (`rm -rf .venv`) and running `uv sync` again. If issues persist, check that you have the latest version of `uv` installed (`uv self update`). |
+| Training runs out of GPU memory           | Make sure you set `XLA_PYTHON_CLIENT_MEM_FRACTION=0.9` (or higher) before running training to allow JAX to use more GPU memory. You can also use `--fsdp-devices <n>` where `<n>` is your number of GPUs, to enable [fully-sharded data parallelism](https://engineering.fb.com/2021/07/15/open-source/fsdp/), which reduces memory usage in exchange for slower training (the amount of slowdown depends on your particular setup). If you are still running out of memory, you may want to consider disabling EMA.        |
+| Policy server connection errors           | Check that the server is running and listening on the expected port. Verify network connectivity and firewall settings between client and server.                                            |
+| Missing norm stats error when training    | Run `scripts/compute_norm_stats.py` with your config name before starting training.                                                                                                          |
+| Dataset download fails                    | Check your internet connection. For HuggingFace datasets, ensure you're logged in (`huggingface-cli login`).                                                                                 |
+| CUDA/GPU errors                           | Verify NVIDIA drivers are installed correctly. For Docker, ensure nvidia-container-toolkit is installed. Check GPU compatibility. You do NOT need CUDA libraries installed at a system level --- they will be installed via uv. You may even want to try *uninstalling* system CUDA libraries if you run into CUDA issues, since system libraries can sometimes cause conflicts. |
+| Import errors when running examples       | Make sure you've installed all dependencies with `uv sync`. Some examples may have additional requirements listed in their READMEs.                    |
+| Action dimensions mismatch                | Verify your data processing transforms match the expected input/output dimensions of your robot. Check the action space definitions in your policy classes.                                  |
+| Diverging training loss                            | Check the `q01`, `q99`, and `std` values in `norm_stats.json` for your dataset. Certain dimensions that are rarely used can end up with very small `q01`, `q99`, or `std` values, leading to huge states and actions after normalization. You can manually adjust the norm stats as a workaround. |

real_inference/source/XPolicyLab/policy/Pi_05/openpi/pyproject.toml

@@ -0,0 +1,138 @@
+[project]
+name = "openpi"
+version = "0.1.0"
+description = "Physical Intelligence open source repo"
+readme = "README.md"
+requires-python = ">=3.11,<3.14"
+license = { file = "LICENSE" }
+dependencies = [
+    "augmax>=0.3.4",
+    "dm-tree>=0.1.8",
+    "einops>=0.8.0",
+    "equinox>=0.11.8",
+    "flatbuffers>=24.3.25",
+    "flax==0.10.2",
+    "fsspec[gcs]>=2024.6.0",
+    "imageio>=2.36.1",
+    "jax[cuda12]==0.5.3",
+    "jaxtyping==0.2.36",
+    "ml_collections==1.0.0",
+    "numpy>=1.22.4,<2.0.0",
+    "numpydantic>=1.6.6",
+    "opencv-python>=4.10.0.84",
+    "openpi-client",
+    "orbax-checkpoint==0.11.13",
+    "pillow>=11.0.0",
+    "sentencepiece>=0.2.0",
+    "torch==2.10.0",
+    "torchvision==0.25.0",
+    "torchcodec==0.10.0",
+    "tqdm-loggable>=0.2",
+    "typing-extensions>=4.12.2",
+    "tyro>=0.9.5",
+    "wandb>=0.19.1",
+    "filelock>=3.16.1",
+    "beartype==0.19.0",
+    "treescope>=0.1.7",
+    "transformers==4.53.2",
+    "rich>=14.0.0",
+    "polars>=1.30.0",
+]
+
+
+[project.urls]
+Repository = "https://github.com/Physical-Intelligence/openpi"
+
+[dependency-groups]
+lerobot = [
+    "lerobot==0.4.4",
+]
+dev = [
+    "pytest>=8.3.4",
+    "ruff>=0.8.6",
+    "pre-commit>=4.0.1",
+    "ipykernel>=6.29.5",
+    "ipywidgets>=8.1.5",
+    "matplotlib>=3.10.0",
+    "pynvml>=12.0.0",
+]
+
+[tool.uv]
+override-dependencies = [
+    "ml-dtypes==0.4.1",
+    "numpy>=1.22.4,<2.0.0",
+    "tensorstore==0.1.74",
+]
+
+[tool.uv.sources]
+openpi-client = { workspace = true }
+dlimp = { git = "https://github.com/kvablack/dlimp", rev = "ad72ce3a9b414db2185bc0b38461d4101a65477a" }
+
+[tool.uv.workspace]
+members = ["packages/*"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+extend-exclude = ["docker", "third_party", "src/openpi/models_pytorch/transformers_replace/*"]
+
+[tool.ruff.lint]
+# https://docs.astral.sh/ruff/rules/
+select = [
+    "B",
+    "C4",
+    "DTZ",
+    "E4",
+    "E7",
+    "E9",
+    "F",
+    "FBT",
+    "FURB",
+    "I",
+    "ICN",
+    "ISC",
+    "LOG",
+    "N",
+    "PD",
+    "PERF",
+    "PIE",
+    "PLC",
+    "PLE",
+    "PLR1",
+    "PLR5",
+    "PLW",
+    "PT",
+    "Q",
+    "RET",
+    "RUF",
+    "SIM",
+    "SLF",
+    "T10",
+    "T20",
+    "UP",
+    "W",
+]
+ignore = [
+    "F722",   # Conflicts with array typing.
+    "T201",   # We use print statements.
+    "PD008",  # Lots of false positives.
+    "ISC001", # Disabling to support ruff format.
+    "LOG015", # Use logger.info.
+]
+unfixable = [
+    "B905", # Fix defaults to strict=False, which is not what we want.
+]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+force-sort-within-sections = true
+single-line-exclusions = ["collections.abc", "typing", "typing_extensions"]
+known-third-party = ["wandb"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+markers = ["manual: should be run manually."]
+testpaths = ["src", "scripts", "packages"]

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/conftest.py

@@ -0,0 +1,17 @@
+import os
+
+import pynvml
+import pytest
+
+
+def set_jax_cpu_backend_if_no_gpu() -> None:
+    try:
+        pynvml.nvmlInit()
+        pynvml.nvmlShutdown()
+    except pynvml.NVMLError:
+        # No GPU found.
+        os.environ["JAX_PLATFORMS"] = "cpu"
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    set_jax_cpu_backend_if_no_gpu()

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/gemma.py

@@ -0,0 +1,459 @@
+# Copyright 2024 Big Vision Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Gemma adaptation for Pi, taken from big_vision.
+
+We follow this einsum axis naming convention:
+  B: batch
+  T: query length
+  S: k/v length
+  N: num query heads
+  K: num k/v heads
+  G: num query heads per k/v head
+  H: head dim
+  D: d_model ("features")
+"""
+
+from collections.abc import Sequence
+import dataclasses
+from typing import Literal, TypeAlias
+
+import einops
+import flax.linen as nn
+import jax
+import jax.numpy as jnp
+
+import openpi.models.lora as lora
+import openpi.shared.array_typing as at
+import openpi.training.sharding as sharding
+
+PALIGEMMA_VOCAB_SIZE = 257_152
+
+
+@dataclasses.dataclass
+class Config:
+    width: int
+    depth: int
+    mlp_dim: int
+    num_heads: int
+    num_kv_heads: int
+    head_dim: int
+    lora_configs: dict[str, lora.LoRAConfig] = dataclasses.field(default_factory=dict)
+
+
+Variant = Literal["dummy", "gemma_300m", "gemma_300m_lora", "gemma_2b", "gemma_2b_lora"]
+
+
+def get_config(variant: Variant) -> Config:
+    """Returns config for specified gemma variant."""
+    if variant == "dummy":
+        return Config(
+            width=64,
+            depth=4,
+            mlp_dim=128,
+            num_heads=8,
+            num_kv_heads=1,
+            head_dim=16,
+        )
+    if variant == "gemma_300m":
+        # 311M params
+        return Config(
+            width=1024,
+            depth=18,
+            mlp_dim=4096,
+            num_heads=8,
+            num_kv_heads=1,
+            head_dim=256,
+        )
+    if variant == "gemma_2b":
+        return Config(
+            width=2048,
+            depth=18,
+            mlp_dim=16_384,
+            num_heads=8,
+            num_kv_heads=1,
+            head_dim=256,
+        )
+    if variant == "gemma_2b_lora":
+        return Config(
+            width=2048,
+            depth=18,
+            mlp_dim=16_384,
+            num_heads=8,
+            num_kv_heads=1,
+            head_dim=256,
+            lora_configs={"attn": lora.LoRAConfig(rank=16, alpha=16.0), "ffn": lora.LoRAConfig(rank=16, alpha=16.0)},
+        )
+    if variant == "gemma_300m_lora":
+        # 311M params
+        return Config(
+            width=1024,
+            depth=18,
+            mlp_dim=4096,
+            num_heads=8,
+            num_kv_heads=1,
+            head_dim=256,
+            lora_configs={"attn": lora.LoRAConfig(rank=32, alpha=32.0), "ffn": lora.LoRAConfig(rank=32, alpha=32.0)},
+        )
+    raise ValueError(f"Unknown variant: {variant}")
+
+
+@at.typecheck
+class RMSNorm(nn.Module):
+    @nn.compact
+    def __call__(self, x, cond):
+        dtype = x.dtype  # original dtype, could be half-precision
+        var = jnp.mean(jnp.square(x.astype(jnp.float32)), axis=-1, keepdims=True)  # compute variance in float32
+        normed_inputs = jnp.asarray(x * jnp.reciprocal(jnp.sqrt(var + 1e-06)))  # compute normalization in float32
+        if cond is None:
+            # regular RMSNorm
+            scale = self.param("scale", nn.initializers.zeros_init(), (x.shape[-1]))
+            normed_inputs = normed_inputs * (
+                1 + scale
+            )  # scale by learned parameter in float32 (matches Flax implementation)
+            return normed_inputs.astype(dtype), None  # return in original dtype
+
+        # adaptive RMSNorm
+        modulation = nn.Dense(x.shape[-1] * 3, kernel_init=nn.initializers.zeros, dtype=dtype)(cond)
+        scale, shift, gate = jnp.split(modulation[:, None, :], 3, axis=-1)
+        normed_inputs = normed_inputs * (1 + scale) + shift  # scale and shift in float32
+        return normed_inputs.astype(dtype), gate
+
+
+@at.typecheck
+class Embedder(nn.Module):
+    """Embedder module."""
+
+    vocab_size: int
+    embed_dim: int
+
+    def setup(self):
+        self.input_embedding_table = self.param(
+            "input_embedding",
+            nn.initializers.normal(),
+            (self.vocab_size, self.embed_dim),
+        )
+
+    def encode(self, x):
+        x = self.input_embedding_table[(x,)]
+        x *= jnp.sqrt(self.embed_dim).astype(x.dtype)
+        return x
+
+    def decode(self, x):
+        return jnp.dot(x, self.input_embedding_table.T)
+
+
+@at.typecheck
+class Attention(nn.Module):
+    """Attention module."""
+
+    configs: Sequence[Config]
+
+    @nn.compact
+    def __call__(self, xs, positions, attn_mask, kv_cache):
+        # all experts must share the same head dim, num heads, and num kv heads for self-attention to work
+        assert all(config.head_dim == self.configs[0].head_dim for config in self.configs)
+        assert all(config.num_heads == self.configs[0].num_heads for config in self.configs)
+        assert all(config.num_kv_heads == self.configs[0].num_kv_heads for config in self.configs)
+
+        dtype = next(x.dtype for x in xs if x is not None)  # original dtype, could be half-precision
+
+        qkvs = []
+        for i, (x, config) in enumerate(zip(xs, self.configs, strict=True)):
+            if x is None:
+                continue
+            if config.num_kv_heads == config.num_heads:
+                qkv_einsum = lora.Einsum(
+                    shape=(3, config.num_heads, config.width, config.head_dim),
+                    name=_name("qkv_einsum", i),
+                    init_fn=nn.initializers.lecun_normal(in_axis=-2, out_axis=-1, batch_axis=(0, 1)),
+                    lora_config=config.lora_configs.get("attn"),
+                )
+                qkvs.append(qkv_einsum("BSD,3KDH->3BSKH", x))
+            else:
+                q_einsum = lora.Einsum(
+                    shape=(config.num_heads, config.width, config.head_dim),
+                    name=_name("q_einsum", i),
+                    init_fn=nn.initializers.lecun_normal(in_axis=-2, out_axis=-1, batch_axis=(0,)),
+                    lora_config=config.lora_configs.get("attn"),
+                )
+                q = q_einsum("BTD,NDH->BTNH", x)
+                kv_einsum = lora.Einsum(
+                    shape=(2, config.num_kv_heads, config.width, config.head_dim),
+                    name=_name("kv_einsum", i),
+                    init_fn=nn.initializers.lecun_normal(in_axis=-2, out_axis=-1, batch_axis=(0, 1)),
+                    lora_config=config.lora_configs.get("attn"),
+                )
+                k, v = kv_einsum("BSD,2KDH->2BSKH", x)
+                qkvs.append((q, k, v))
+
+        q, k, v = (jnp.concatenate(y, axis=1) for y in zip(*qkvs, strict=True))
+
+        q = _apply_rope(q, positions=positions)
+        q *= self.configs[0].head_dim ** -0.5
+
+        k = _apply_rope(k, positions=positions)
+
+        # should still be half-precision here (if input was half-precision)
+        assert q.dtype == k.dtype == v.dtype == dtype
+
+        if kv_cache is not None:
+            cache_k, cache_v = kv_cache
+            k = jnp.concatenate([cache_k, k], axis=1)
+            v = jnp.concatenate([cache_v, v], axis=1)
+
+        q = einops.rearrange(q, "B T (K G) H -> B T K G H", K=self.configs[0].num_kv_heads)
+        logits = jnp.einsum("BTKGH,BSKH->BKGTS", q, k, preferred_element_type=jnp.float32)
+
+        if attn_mask.shape != (q.shape[0], 1, q.shape[1], k.shape[1]):
+            raise ValueError(
+                f"Attention mask with shape {attn_mask.shape} but shapes for q and k are: {q.shape} and {k.shape}"
+            )
+
+        # big_neg = jnp.finfo(logits.dtype).min
+        big_neg = -2.3819763e38  # See gemma/modules.py
+        masked_logits = jnp.where(attn_mask[:, :, None, :, :], logits, big_neg)
+
+        probs = jax.nn.softmax(masked_logits, axis=-1).astype(dtype)
+
+        encoded = jnp.einsum("BKGTS,BSKH->BTKGH", probs, v)
+        encoded = einops.rearrange(encoded, "B T K G H -> B T (K G) H")
+
+        out = []
+        start = 0
+        for i, (x, config) in enumerate(zip(xs, self.configs, strict=True)):
+            if x is not None:
+                end = start + x.shape[1]
+                out_einsum = lora.Einsum(
+                    shape=(config.num_heads, config.head_dim, config.width),
+                    name=_name("attn_vec_einsum", i),
+                    init_fn=nn.initializers.lecun_normal(in_axis=(-3, -2), out_axis=-1),
+                    lora_config=config.lora_configs.get("attn"),
+                )
+                out.append(out_einsum("BTNH,NHD->BTD", encoded[:, start:end]))
+                start = end
+            else:
+                out.append(None)
+
+        return out, (k, v)
+
+
+@at.typecheck
+class FeedForward(nn.Module):
+    """Feed forward module."""
+
+    features: int
+    hidden_dim: int
+
+    @nn.compact
+    def __call__(self, x):
+        dtype = x.dtype  # original dtype, could be half-precision
+        w_gating = self.param(
+            "gating_einsum",
+            nn.initializers.lecun_normal(in_axis=-2, out_axis=-1, batch_axis=(0,)),
+            (2, self.features, self.hidden_dim),
+        ).astype(dtype)
+        ff_gate = jnp.dot(x, w_gating[0])
+        gate_value = nn.gelu(ff_gate)
+
+        ff1 = jnp.dot(x, w_gating[1])
+        activations = gate_value * ff1
+
+        w_linear = self.param(
+            "linear",
+            nn.initializers.lecun_normal(in_axis=-2, out_axis=-1),
+            (self.hidden_dim, self.features),
+        ).astype(dtype)
+        outputs = jnp.dot(activations, w_linear)
+        assert outputs.dtype == dtype
+        return outputs
+
+
+@at.typecheck
+class Block(nn.Module):
+    """Transformer block."""
+
+    configs: tuple[Config, ...]
+
+    dropout: float = 0.0
+    dropout_bdims: tuple[int, ...] = ()
+
+    @nn.compact
+    def __call__(self, xs, kv_cache, positions, attn_mask, adarms_cond, deterministic=True):  # noqa: FBT002
+        xs = sharding.activation_sharding_constraint(xs)
+        drop = nn.Dropout(self.dropout, self.dropout_bdims) if self.dropout else lambda x, _: x
+
+        attn = Attention(configs=self.configs, name="attn")
+
+        pre_attn = []
+        gates = []
+        for i, x in enumerate(xs):
+            if x is not None:
+                x, gate = RMSNorm(name=_name("pre_attention_norm", i))(x, adarms_cond[i])  # noqa: PLW2901
+            pre_attn.append(x)
+            gates.append(gate if x is not None else None)
+
+        pre_attn = sharding.activation_sharding_constraint(pre_attn)
+        post_attn, kv_cache = attn(pre_attn, positions, attn_mask, kv_cache)
+        post_attn = jax.tree.map(lambda x: drop(x, deterministic), post_attn)
+        post_attn = sharding.activation_sharding_constraint(post_attn)
+        xs = [_gated_residual(x, y, gate) for x, y, gate in zip(xs, post_attn, gates, strict=True)]
+        xs = sharding.activation_sharding_constraint(xs)
+
+        out = []
+        gates = []
+        for i, (x, config) in enumerate(zip(xs, self.configs, strict=True)):
+            if x is not None:
+                x, gate = RMSNorm(name=_name("pre_ffw_norm", i))(x, adarms_cond[i])  # noqa: PLW2901
+                x = lora.FeedForward(  # noqa: PLW2901
+                    features=config.width,
+                    hidden_dim=config.mlp_dim,
+                    name=_name("mlp", i),
+                    lora_config=config.lora_configs.get("ffn"),
+                )(x)
+            out.append(x)
+            gates.append(gate if x is not None else None)
+
+        out = sharding.activation_sharding_constraint(out)
+        out = jax.tree.map(lambda x: drop(x, deterministic), out)
+        xs = [_gated_residual(x, y, gate) for x, y, gate in zip(xs, out, gates, strict=True)]
+        xs = sharding.activation_sharding_constraint(xs)
+
+        return xs, kv_cache
+
+
+KVCache: TypeAlias = tuple[at.Float[at.Array, "l b _t _k _h"], at.Float[at.Array, "l b _t _v _h"]]
+
+
+@at.typecheck
+class Module(nn.Module):
+    """Transformer model, supporting a mixture of different weights for different tokens."""
+
+    configs: Sequence[Config]  # list of configs, one for each expert
+    embed_dtype: str
+
+    dropout: float = 0.0
+    dropout_bdims: tuple[int, ...] = ()  # Every float is dropped independently.
+    adarms: bool = False
+
+    def setup(self):
+        # all experts must have the same depth
+        assert all(config.depth == self.configs[0].depth for config in self.configs)
+
+        self.embedder = Embedder(
+            vocab_size=PALIGEMMA_VOCAB_SIZE,
+            embed_dim=self.configs[0].width,  # embedder for first expert only
+            name="embedder",
+        )
+        block_cls = nn.remat(
+            Block,
+            prevent_cse=False,
+            static_argnums=(5,),  # 0=self, 6=deterministic
+            policy=jax.checkpoint_policies.nothing_saveable,
+        )
+        self.layers = nn.scan(
+            block_cls,
+            variable_axes={"params": 0},
+            split_rngs={"params": True, "dropout": True},
+            in_axes=(
+                0,
+                nn.broadcast,
+                nn.broadcast,
+                nn.broadcast,
+                nn.broadcast,
+            ),  # 0=kv_cache, 1=positions, 2=mask, 3=adarms_cond, 4=deterministic
+            length=self.configs[0].depth,
+        )(
+            configs=self.configs,
+            dropout=self.dropout,
+            dropout_bdims=self.dropout_bdims,
+        )
+        self.final_norms = [RMSNorm(name=_name("final_norm", i)) for i in range(len(self.configs))]
+
+    @at.typecheck
+    def embed(self, tokens: at.Int[at.Array, "b t"]) -> at.Float[at.Array, "b t d"]:
+        return self.embedder.encode(tokens).astype(self.embed_dtype)
+
+    @at.typecheck
+    def __call__(
+        self,
+        # list of token arrays, one for each expert, or None if that expert should not be run
+        embedded: Sequence[at.Float[at.Array, "b _t _d"] | None],
+        positions: at.Int[at.Array, "b t"],
+        mask: at.Bool[at.Array, "b t s"],
+        adarms_cond: Sequence[at.Float[at.Array, "b _d"] | None] | None = None,
+        *,
+        kv_cache: KVCache | None = None,
+        deterministic: bool = True,
+    ) -> tuple[Sequence[at.Float[at.Array, "b _t _d"] | None], KVCache]:
+        embedded = jax.tree.map(lambda e: e.astype(self.embed_dtype), embedded)
+        mask = jnp.asarray(mask)[:, None, :, :]
+        if adarms_cond is None:
+            adarms_cond = [None] * len(self.configs)
+
+        embedded, kv_cache = self.layers(embedded, kv_cache, positions, mask, adarms_cond, deterministic)
+
+        assert all(e.dtype == jnp.dtype(self.embed_dtype) for e in embedded if e is not None)
+
+        return [
+            f(e, a)[0] if e is not None else e for f, e, a in zip(self.final_norms, embedded, adarms_cond, strict=True)
+        ], kv_cache
+
+    def init(self, use_adarms: Sequence[bool]):
+        """Convenience method for initializing all parameters, necessary due to the quirks of linen."""
+        self.embed(jnp.zeros((1, 1), dtype=jnp.int32))
+        self(
+            [jnp.zeros((1, 1, c.width)) for c in self.configs],
+            jnp.zeros((1, len(self.configs)), dtype=jnp.int32),
+            jnp.zeros((1, len(self.configs), len(self.configs)), dtype=bool),
+            adarms_cond=[jnp.zeros((1, c.width)) if u else None for u, c in zip(use_adarms, self.configs, strict=True)],
+        )
+
+
+def _apply_rope(x, *, positions, max_wavelength=10_000):
+    """Applies RoPE positions [B, L] to x [B, L, H, D]."""
+    freq_exponents = (2.0 / x.shape[-1]) * jnp.arange(x.shape[-1] // 2, dtype=jnp.float32)
+    timescale = max_wavelength**freq_exponents
+    radians = positions[..., None] / timescale[None, None, :]
+    radians = radians[..., None, :]
+    assert radians.dtype == jnp.float32
+    # radians.shape = [...,L,1,d=D/2]
+    sin, cos = jnp.sin(radians), jnp.cos(radians)
+    x1, x2 = jnp.split(x, 2, axis=-1)
+    res = jnp.concatenate([x1 * cos - x2 * sin, x2 * cos + x1 * sin], axis=-1)
+    assert res.dtype == jnp.float32
+    # The original bigvision impl allows RoPE to upcast to float32. It is then immediately downcast again to the cache
+    # dtype when in inference mode (but not in training mode). I don't think any of this was intentional. Based on the
+    # original DeepMind impl, as well as the widely-used transformers impl, it is ok to always downcast back to bfloat16
+    # here.
+    return res.astype(x.dtype)
+
+
+def _name(name, i):
+    # we name layers like this because we want the first expert's weights to have no suffix (e.g., "attn"), so that they
+    # can be loaded seamlessly from the existing PaliGemma checkpoint. subsequent experts will have a suffix (e.g.,
+    # "attn_1") and their weights will be initialized from scratch. in practice, we only use two experts -- PaliGemma,
+    # and the action expert.
+    if i == 0:
+        return name
+    return f"{name}_{i}"
+
+
+def _gated_residual(x, y, gate):
+    assert (x is None) == (y is None)
+    if x is None:
+        return None
+    if gate is None:
+        return x + y
+    return x + y * gate

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/gemma_fast.py

@@ -0,0 +1,437 @@
+# Copyright 2024 Big Vision Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Gemma model implementation from big_vision/models/ppp/gemma.py (with small modifications for NNX compatibility)
+Used for FAST autoregressive policies.
+"""
+
+import dataclasses
+from typing import Literal, TypeAlias
+
+import einops
+import flax.linen as nn
+import jax
+import jax.numpy as jnp
+import ml_collections
+
+import openpi.models.lora as lora
+import openpi.shared.array_typing as at
+
+Variant = Literal["gemma_2b", "gemma_2b_lora"]
+
+
+def get_config(variant):
+    """Returns config for specified gemma variant."""
+    if variant == "gemma_2b":
+        return ml_collections.ConfigDict(
+            {
+                "variant": variant,
+                "width": 2048,
+                "depth": 18,
+                "mlp_dim": 16_384,
+                "num_heads": 8,
+                "num_kv_heads": 1,
+                "head_dim": 256,
+                "norm_eps": 1e-6,
+                "vocab_size": 257_152,
+                "scan": True,
+                "remat_policy": "nothing_saveable",
+            }
+        )
+    if variant == "gemma_2b_lora":
+        return ml_collections.ConfigDict(
+            {
+                "variant": variant,
+                "width": 2048,
+                "depth": 18,
+                "mlp_dim": 16_384,
+                "num_heads": 8,
+                "num_kv_heads": 1,
+                "head_dim": 256,
+                "norm_eps": 1e-6,
+                "vocab_size": 257_152,
+                "scan": True,
+                "remat_policy": "nothing_saveable",
+                "lora_configs": {
+                    "attn": lora.LoRAConfig(rank=16, alpha=16.0),
+                    "ffn": lora.LoRAConfig(rank=16, alpha=16.0),
+                },
+            }
+        )
+    raise ValueError(f"Unknown variant: {variant}")
+
+
+@at.typecheck
+class Einsum(nn.Module):
+    shape: tuple[int, ...]
+
+    @nn.compact
+    def __call__(self, eqn, x):
+        dtype = x.dtype  # original dtype, could be half-precision
+        w = self.param("w", nn.initializers.zeros_init(), self.shape).astype(dtype)
+        return jnp.einsum(eqn, x, w)
+
+
+@at.typecheck
+class RMSNorm(nn.Module):
+    @nn.compact
+    def __call__(self, x):
+        dtype = x.dtype  # original dtype, could be half-precision
+        scale = self.param("scale", nn.initializers.zeros_init(), (x.shape[-1]))
+        var = jnp.mean(jnp.square(x.astype(jnp.float32)), axis=-1, keepdims=True)  # compute variance in float32
+        normed_inputs = jnp.asarray(x * jnp.reciprocal(jnp.sqrt(var + 1e-06)))  # compute normalization in float32
+        normed_inputs = normed_inputs * (
+            1 + scale
+        )  # scale by learned parameter in float32 (matches Flax implementation)
+        return normed_inputs.astype(dtype)  # return in original dtype
+
+
+@at.typecheck
+class Embedder(nn.Module):
+    """Embedder module."""
+
+    vocab_size: int
+    embed_dim: int
+
+    def setup(self):
+        self.input_embedding_table = self.param(
+            "input_embedding",
+            nn.initializers.zeros_init(),
+            (self.vocab_size, self.embed_dim),
+        )
+
+    def encode(self, x):
+        x = self.input_embedding_table[(x,)]
+        x *= jnp.sqrt(self.embed_dim).astype(x.dtype)
+        return x
+
+    def decode(self, x):
+        return jnp.dot(x, self.input_embedding_table.T)
+
+
+@at.typecheck
+class Attention(nn.Module):
+    """Attention module."""
+
+    num_heads: int
+    num_kv_heads: int
+    features: int
+    head_dim: int
+
+    cache_dtype: str | None = None
+
+    lora_config: lora.LoRAConfig | None = None
+
+    def setup(self):
+        if self.num_kv_heads == self.num_heads:
+            self.qkv_einsum = lora.Einsum(
+                shape=(3, self.num_heads, self.features, self.head_dim),
+                name="qkv_einsum",
+                init_fn=nn.initializers.lecun_normal(in_axis=-2, out_axis=-1, batch_axis=(0, 1)),
+                lora_config=self.lora_config,
+            )
+        else:
+            self.q_einsum = lora.Einsum(
+                shape=(self.num_heads, self.features, self.head_dim),
+                name="q_einsum",
+                init_fn=nn.initializers.lecun_normal(in_axis=-2, out_axis=-1, batch_axis=(0,)),
+                lora_config=self.lora_config,
+            )
+            self.kv_einsum = lora.Einsum(
+                shape=(2, self.num_kv_heads, self.features, self.head_dim),
+                name="kv_einsum",
+                init_fn=nn.initializers.lecun_normal(in_axis=-2, out_axis=-1, batch_axis=(0, 1)),
+                lora_config=self.lora_config,
+            )
+        self.attn_vec_einsum = lora.Einsum(
+            shape=(self.num_heads, self.head_dim, self.features),
+            name="attn_vec_einsum",
+            init_fn=nn.initializers.lecun_normal(in_axis=-2, out_axis=-1, batch_axis=(0,)),
+            lora_config=self.lora_config,
+        )
+
+    def _init_cache(self, k, v, cache_size):
+        """Initialize KV cache"""
+        prefill_len = k.shape[1]
+        pad_width = ((0, 0), (0, cache_size - prefill_len), (0, 0), (0, 0))
+        cache_dtype = self.cache_dtype or k.dtype
+        k_cache = jnp.pad(k.astype(cache_dtype), pad_width)
+        v_cache = jnp.pad(v.astype(cache_dtype), pad_width)
+        idx = jnp.zeros((k.shape[0],), dtype=jnp.int32) + prefill_len
+        return idx, k_cache, v_cache
+
+    def _update_cache(self, k, v, idx, k_cache, v_cache):
+        """Update KV cache with new values"""
+        assert k.shape[1] == 1, "Only support kv-cache updates of length 1"
+        indices = (0, idx[0], 0, 0)
+        cache_dtype = self.cache_dtype or k.dtype
+        k_new = jax.lax.dynamic_update_slice(k_cache, k.astype(cache_dtype), indices)
+        v_new = jax.lax.dynamic_update_slice(v_cache, v.astype(cache_dtype), indices)
+        idx_new = idx + 1
+        return idx_new, k_new, v_new
+
+    @nn.compact
+    def __call__(self, x, positions, attn_mask, kv_cache, decode, deterministic=True):  # noqa: FBT002
+        dtype = x.dtype  # original dtype, could be half-precision
+        if self.num_kv_heads == self.num_heads:
+            q, k, v = self.qkv_einsum("BSD,3KDH->3BSKH", x)
+        else:
+            q = self.q_einsum("BTD,NDH->BTNH", x)
+            k, v = self.kv_einsum("BSD,2KDH->2BSKH", x)
+
+        q = _apply_rope(q, positions=positions)  # promotes to float32
+        q *= self.head_dim**-0.5
+
+        k = _apply_rope(k, positions=positions)  # promotes to float32
+
+        if kv_cache is None:
+            idx, k_cache, v_cache = self._init_cache(k, v, attn_mask.shape[-1])
+        else:
+            idx, k_cache, v_cache = kv_cache
+            idx, k_cache, v_cache = self._update_cache(k, v, idx, k_cache, v_cache)
+
+        k, v = k_cache, v_cache
+        kv_cache = (idx, k_cache, v_cache)
+
+        q = einops.rearrange(q, "B T (K G) H -> B T K G H", K=self.num_kv_heads)
+        logits = jnp.einsum("BTKGH,BSKH->BKGTS", q, k, preferred_element_type=jnp.float32)
+
+        if attn_mask.shape != (q.shape[0], 1, q.shape[1], k.shape[1]):
+            raise ValueError(
+                f"Attention mask with shape {attn_mask.shape} but shapes for q and k are: {q.shape} and {k.shape}"
+            )
+
+        # big_neg = jnp.finfo(logits.dtype).min
+        big_neg = -2.3819763e38  # See gemma/modules.py
+        masked_logits = jnp.where(attn_mask[:, :, None, :, :], logits, big_neg)
+
+        probs = jax.nn.softmax(masked_logits, axis=-1).astype(dtype)
+
+        encoded = jnp.einsum("BKGTS,BSKH->BTKGH", probs, v)
+        encoded = einops.rearrange(encoded, "B T K G H -> B T (K G) H")
+        return self.attn_vec_einsum("BTNH,NHD->BTD", encoded), kv_cache
+
+
+@at.typecheck
+class Block(nn.Module):
+    """Transformer block."""
+
+    num_heads: int
+    num_kv_heads: int
+    embed_dim: int
+    head_dim: int
+    hidden_dim: int
+
+    dropout: float = 0.0
+    dropout_bdims: tuple[int, ...] = ()
+    cache_dtype: str | None = None
+    lora_configs: ml_collections.ConfigDict = dataclasses.field(default_factory=ml_collections.ConfigDict)
+
+    def setup(self):
+        self.pre_attention_norm = RMSNorm()
+        self.attn = Attention(
+            num_heads=self.num_heads,
+            num_kv_heads=self.num_kv_heads,
+            features=self.embed_dim,
+            head_dim=self.head_dim,
+            cache_dtype=self.cache_dtype,
+            lora_config=self.lora_configs.get("attn"),
+        )
+        self.pre_ffw_norm = RMSNorm()
+        self.mlp = lora.FeedForward(
+            features=self.embed_dim, hidden_dim=self.hidden_dim, name="mlp", lora_config=self.lora_configs.get("ffn")
+        )
+        if self.dropout:
+            self.drop = nn.Dropout(self.dropout, self.dropout_bdims)
+        else:
+            self.drop = lambda x, _: x
+
+    def __call__(self, x, kv_cache, positions, attn_mask, decode, deterministic=True):  # noqa: FBT002
+        x = nn.with_logical_constraint(x, ("act_batch", "act_len", "act_emb"))
+        inputs_normalized = self.pre_attention_norm(x)
+        attn_output, kv_cache = self.attn(inputs_normalized, positions, attn_mask, kv_cache, decode, deterministic)
+        attn_output = self.drop(attn_output, deterministic)
+        attn_output += x
+        residual = attn_output
+        attn_output = self.pre_ffw_norm(attn_output)
+        outputs = self.mlp(attn_output)
+        outputs = self.drop(outputs, deterministic)
+        outputs = residual + outputs
+        return outputs, kv_cache
+
+
+KVCache: TypeAlias = tuple[at.Int[at.Array, " b"], at.Float[at.Array, "b _t _k _h"], at.Float[at.Array, "b _t _v _h"]]
+
+
+@at.typecheck
+class Module(nn.Module):
+    """gemma model."""
+
+    variant: str
+
+    width: int
+    depth: int
+    mlp_dim: int
+    num_heads: int
+    num_kv_heads: int
+    head_dim: int
+    norm_eps: float
+    vocab_size: int
+    embed_dtype: str
+
+    dropout: float = 0.0
+    dropout_bdims: tuple[int, ...] = ()  # Every float is dropped independently.
+    cache_dtype: str | None = None
+
+    scan: bool = False
+    remat_policy: str = "none"
+    lora_configs: ml_collections.ConfigDict = dataclasses.field(default_factory=ml_collections.ConfigDict)
+
+    @nn.compact
+    def __call__(
+        self,
+        tokens=None,
+        embedded_prefix=None,
+        embed_only=False,  # noqa: FBT002
+        pre_logits=None,
+        positions=None,
+        mask=None,
+        decode=False,  # noqa: FBT002
+        kv_cache=None,
+        deterministic=True,  # noqa: FBT002
+        return_prelogits=False,  # noqa: FBT002
+    ):
+        """Embed only, or complete forward pass.
+
+        Args:
+          tokens: Embedded, then and appended to `embedded_prefix`. Can be None.
+          embedded_prefix: Optional prefix that is already embedded.
+          embed_only: Whether to compute embeddings only.
+          pre_logits: If present computes logits from pre_logits and returns.
+          positions: Optional `[B, T]` allows to specify the absolute position of
+            the tokens.
+          mask: Optional attention mask `[B, T, S]`.
+          decode: Whether to use kv-cache. Caller must pass masks and positions.
+          deterministic: Forwarded to all dropout layers.
+          return_prelogits: Whether to return the pre-logits.
+
+        Returns:
+          If `embed_only=False`, then `(logits, out)` will be returned.
+          If `embed_only=True`, then the embeddings will be returned.
+          If `return_prelogits=True`, then the pre-logits will be returned.
+        """
+        out = {}
+
+        embedder = Embedder(vocab_size=self.vocab_size, embed_dim=self.width, name="embedder")
+
+        if pre_logits is not None:
+            x = out["pre_logits"] = pre_logits
+            logits = out["logits"] = embedder.decode(x)
+            return logits, out
+
+        x = []
+        if embedded_prefix is not None:
+            x.append(embedded_prefix)
+        if tokens is not None:
+            x.append(embedder.encode(tokens))
+
+        x = jnp.concatenate(x, axis=-2)
+        x = x.astype(self.embed_dtype)
+        batch_size, seq_len, width = x.shape
+
+        if embed_only:
+            return x
+
+        if decode:
+            assert positions is not None and mask is not None, (  # noqa: PT018
+                "Must explicitly pass positions and mask for decoding."
+            )
+
+        if positions is None:
+            positions = jnp.arange(seq_len).astype(jnp.int32)[None, :]
+        assert positions.shape[1] == x.shape[1], (positions.shape, x.shape)
+
+        if mask is None:
+            mask = nn.attention.make_causal_mask(jnp.ones([batch_size, seq_len]))
+        if mask.ndim == 3:
+            mask = mask[:, None, :, :]
+        cache_size = max(seq_len, mask.shape[-1])
+        assert mask.shape == (batch_size, 1, seq_len, cache_size), mask.shape
+
+        if self.remat_policy == "none":
+            block_cls = Block
+        else:
+            block_cls = nn.remat(
+                Block,
+                prevent_cse=not self.scan,
+                static_argnums=(5, 6),  # 0=self, 5=decode, 6=deterministic
+                policy=getattr(jax.checkpoint_policies, self.remat_policy),
+            )
+
+        block_kw = {
+            "num_heads": self.num_heads,
+            "head_dim": self.head_dim,
+            "num_kv_heads": self.num_kv_heads,
+            "embed_dim": width,
+            "hidden_dim": self.mlp_dim,
+            "dropout": self.dropout,
+            "dropout_bdims": self.dropout_bdims,
+            "cache_dtype": self.cache_dtype,
+            "lora_configs": self.lora_configs,
+        }
+        layers = self.scope.push("layers")
+        blocks = [
+            nn.scan(
+                block_cls,
+                variable_axes={"params": 0},
+                split_rngs={"params": True, "dropout": True},
+                in_axes=(0, nn.broadcast, nn.broadcast, nn.broadcast, nn.broadcast),  # 0=kv_cache, 1=positions, 2=mask
+                length=self.depth,
+            )(parent=layers, **block_kw)
+        ]
+        for block in blocks:
+            x, kv_cache = block(x, kv_cache, positions, mask, decode, deterministic)
+
+        assert x.dtype == jnp.dtype(self.embed_dtype)  # Sanity check.
+        out["encoded"] = x
+
+        x = RMSNorm(name="final_norm")(x)
+        out["pre_logits"] = x
+        if return_prelogits:
+            return x, kv_cache, out
+
+        x = embedder.decode(x)
+        out["logits"] = x
+
+        return x, kv_cache, out
+
+    def init(self):
+        """Convenience method for initializing all parameters, necessary due to the quirks of linen."""
+        self(jnp.zeros((1, 1), dtype=jnp.int32))
+
+
+def _apply_rope(x, *, positions, max_wavelength=10_000):
+    """Applies RoPE positions [B, L] to x [B, L, H, D]."""
+    freq_exponents = (2.0 / x.shape[-1]) * jnp.arange(x.shape[-1] // 2, dtype=jnp.float32)
+    timescale = max_wavelength**freq_exponents
+    radians = positions[..., None] / timescale[None, None, :]
+    radians = radians[..., None, :]
+    assert radians.dtype == jnp.float32
+    # radians.shape = [...,L,1,d=D/2]
+    sin, cos = jnp.sin(radians), jnp.cos(radians)
+    x1, x2 = jnp.split(x, 2, axis=-1)
+    res = jnp.concatenate([x1 * cos - x2 * sin, x2 * cos + x1 * sin], axis=-1)
+    assert res.dtype == jnp.float32
+    return res

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/lora.py

@@ -0,0 +1,148 @@
+import math
+import re
+
+import flax.linen as nn
+import flax.struct as struct
+import jax.numpy as jnp
+
+import openpi.shared.array_typing as at
+
+
+@struct.dataclass
+class LoRAConfig:
+    """Configuration for LoRA."""
+
+    # LoRA rank.
+    rank: int
+    # LoRA scaling factor.
+    alpha: float = 1.0
+    # Initialization function for LoRA parameters.
+    init_fn: nn.initializers.Initializer = nn.initializers.normal(stddev=0.01)
+    # Enable rank-stabilized LoRA: https://arxiv.org/pdf/2312.03732
+    rslora: bool = False
+    # Axes in the weight to apply LoRA to. Should typically be the last two axes.
+    axes: tuple[int, int] = (-2, -1)
+    # Axis label which is used by LoRA in einsum equations. Must not be present in the original equation.
+    label: str = "L"
+
+    @property
+    def scaling_value(self) -> float:
+        return self.alpha / math.sqrt(self.rank) if self.rslora else self.alpha / self.rank
+
+
+class Einsum(nn.Module):
+    """Einsum with LoRA support. Can be used as a drop-in replacement for the Gemma Einsum."""
+
+    # Shape of the weight.
+    shape: tuple[int, ...]
+    # Initialization function for the weight.
+    init_fn: nn.initializers.Initializer = nn.initializers.zeros
+    # If not None, apply LoRA to the weight.
+    lora_config: LoRAConfig | None = None
+
+    def setup(self):
+        self.w = self.param("w", self.init_fn, self.shape)
+
+        if config := self.lora_config:
+            # Setup LoRA parameters.
+            shape_a, shape_b = list(self.shape), list(self.shape)
+            shape_a[config.axes[1]] = config.rank
+            shape_b[config.axes[0]] = config.rank
+            self.w_a = self.param("lora_a", config.init_fn, shape_a)
+            self.w_b = self.param("lora_b", config.init_fn, shape_b)
+
+    @nn.compact
+    def __call__(self, eqn: str, x):
+        dtype = x.dtype  # original dtype, could be half-precision
+        result = jnp.einsum(eqn, x, self.w.astype(dtype))
+
+        if config := self.lora_config:
+            eqn_a, eqn_b = self._make_lora_eqns(eqn)
+            lora = jnp.einsum(eqn_a, x, self.w_a.astype(dtype))
+            lora = jnp.einsum(eqn_b, lora, self.w_b.astype(dtype))
+            result = result + lora * config.scaling_value
+
+        return result
+
+    def _make_lora_eqns(self, eqn: str) -> tuple[str, str]:
+        if "L" in eqn:
+            raise ValueError(f"L already in eqn: {eqn}")
+        if not (m := re.match("(.*),(.*)->(.*)", eqn)):
+            raise ValueError(f"Unsupported einsum eqn: {eqn}")
+        lhs, rhs, out = m.groups()
+
+        assert self.lora_config is not None
+        a_label, b_label = (rhs[x] for x in self.lora_config.axes)
+        label = self.lora_config.label
+
+        a_rhs = rhs.replace(b_label, label)
+        a_out = out.replace(b_label, label)
+        eqn_a = f"{lhs},{a_rhs}->{a_out}"
+
+        b_rhs = rhs.replace(a_label, label)
+        eqn_b = f"{a_out},{b_rhs}->{out}"
+
+        return eqn_a, eqn_b
+
+
+class FeedForward(nn.Module):
+    """Feed forward module."""
+
+    features: int
+    hidden_dim: int
+    # If not None, apply LoRA to the weight.
+    lora_config: LoRAConfig | None = None
+
+    def setup(self):
+        self.w_gating = self.param(
+            "gating_einsum",
+            nn.initializers.lecun_normal(in_axis=-2, out_axis=-1, batch_axis=(0,)),
+            (2, self.features, self.hidden_dim),
+        )
+        self.w_linear = self.param(
+            "linear",
+            nn.initializers.lecun_normal(in_axis=-2, out_axis=-1),
+            (self.hidden_dim, self.features),
+        )
+        self.w_gating_lora = None
+        self.w_linear_lora = None
+        if self.lora_config:
+            # Setup LoRA parameters.
+            # TODO: follow up with a simplified init_fn api.
+            self.w_gating_lora = (
+                self.param("gating_einsum_lora_a", self.lora_config.init_fn, (2, self.features, self.lora_config.rank)),
+                self.param(
+                    "gating_einsum_lora_b", self.lora_config.init_fn, (2, self.lora_config.rank, self.hidden_dim)
+                ),
+            )
+            self.w_linear_lora = (
+                self.param("linear_lora_a", self.lora_config.init_fn, (self.hidden_dim, self.lora_config.rank)),
+                self.param("linear_lora_b", self.lora_config.init_fn, (self.lora_config.rank, self.features)),
+            )
+
+    @nn.compact
+    def __call__(self, x):
+        dtype = x.dtype  # original dtype, could be half-precision
+        ff_gate = self._dot(
+            x,
+            self.w_gating[0],
+            None if self.w_gating_lora is None else (self.w_gating_lora[0][0], self.w_gating_lora[1][0]),
+        )
+        gate_value = nn.gelu(ff_gate)
+
+        ff1 = self._dot(
+            x,
+            self.w_gating[1],
+            None if self.w_gating_lora is None else (self.w_gating_lora[0][1], self.w_gating_lora[1][1]),
+        )
+        activations = gate_value * ff1
+
+        outputs = self._dot(activations, self.w_linear, self.w_linear_lora)
+        assert outputs.dtype == dtype
+        return outputs
+
+    def _dot(self, x: at.Array, w: at.Array, lora_weights: tuple[at.Array, at.Array] | None) -> at.Array:
+        base = jnp.dot(x, w.astype(x.dtype))
+        if lora_weights is None:
+            return base
+        return base + jnp.dot(jnp.dot(x, lora_weights[0].astype(x.dtype)), lora_weights[1].astype(x.dtype))

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/lora_test.py

@@ -0,0 +1,94 @@
+import flax.linen as nn
+import jax
+import jax.numpy as jnp
+
+import openpi.models.lora as lora
+
+
+def test_lora_einsum_params_shape():
+    shape = (3, 8, 32, 4)  # (3KDH)
+    einsum = lora.Einsum(shape)
+    lora0 = lora.Einsum(shape, lora_config=lora.LoRAConfig(rank=2))
+    lora1 = lora.Einsum(shape, lora_config=lora.LoRAConfig(rank=2, axes=(1, 2)))
+
+    key = jax.random.key(0)
+    x = jax.random.normal(key, (8, 64, 32))  # (BSD)
+    eqn = "BSD,3KDH->3BSKH"
+
+    # Ensure that lora parameters are not initialized when LoRA is not used.
+    params = einsum.init(key, eqn, x)
+    assert "lora_a" not in params["params"]
+    assert "lora_b" not in params["params"]
+
+    # Check that default axes work.
+    params_lora0 = lora0.init(key, eqn, x)
+    assert params_lora0["params"]["lora_a"].shape == (3, 8, 32, 2)
+    assert params_lora0["params"]["lora_b"].shape == (3, 8, 2, 4)
+
+    # Check that user provided axes work.
+    params_lora1 = lora1.init(key, eqn, x)
+    assert params_lora1["params"]["lora_a"].shape == (3, 8, 2, 4)
+    assert params_lora1["params"]["lora_b"].shape == (3, 2, 32, 4)
+
+
+def test_lora_einsum_same_output():
+    shape = (3, 8, 32, 4)  # (3KDH)
+    einsum = lora.Einsum(shape)
+    einsum_lora = lora.Einsum(shape, lora_config=lora.LoRAConfig(rank=2, init_fn=nn.initializers.zeros))
+
+    key = jax.random.key(0)
+    x = jax.random.normal(key, (8, 64, 32))  # (BSD)
+    eqn = "BSD,3KDH->3BSKH"
+
+    params = einsum.init(key, eqn, x)
+    output = einsum.apply(params, eqn, x)
+
+    params_lora = einsum_lora.init(key, eqn, x)
+    output_lora = einsum_lora.apply(params_lora, eqn, x)
+
+    # Results are the same since the LoRA parameters are initialized to zeros.
+    assert jnp.allclose(output, output_lora)
+
+
+def test_lora_ffn_params_shape():
+    ffn = lora.FeedForward(features=8, hidden_dim=32)
+    ffn_lora = lora.FeedForward(
+        features=8,
+        hidden_dim=32,
+        lora_config=lora.LoRAConfig(rank=2),
+    )
+
+    key = jax.random.key(0)
+    x = jax.random.normal(key, (2, 8))
+
+    params = ffn.init(key, x)
+    assert params["params"]["gating_einsum"].shape == (2, 8, 32)
+    assert params["params"]["linear"].shape == (32, 8)
+
+    params_lora = ffn_lora.init(key, x)
+    assert params_lora["params"]["gating_einsum"].shape == (2, 8, 32)
+    assert params_lora["params"]["linear"].shape == (32, 8)
+    assert params_lora["params"]["gating_einsum_lora_a"].shape == (2, 8, 2)
+    assert params_lora["params"]["gating_einsum_lora_b"].shape == (2, 2, 32)
+    assert params_lora["params"]["linear_lora_a"].shape == (32, 2)
+    assert params_lora["params"]["linear_lora_b"].shape == (2, 8)
+
+
+def test_lora_ffn_same_output():
+    ffn = lora.FeedForward(features=8, hidden_dim=32)
+    ffn_lora = lora.FeedForward(
+        features=8,
+        hidden_dim=32,
+        lora_config=lora.LoRAConfig(rank=2, init_fn=nn.initializers.zeros),
+    )
+
+    key = jax.random.key(0)
+    x = jax.random.normal(key, (2, 8))
+
+    params = ffn.init(key, x)
+    output = ffn.apply(params, x)
+
+    params_lora = ffn_lora.init(key, x)
+    output_lora = ffn_lora.apply(params_lora, x)
+
+    assert jnp.allclose(output, output_lora)

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/model.py

@@ -0,0 +1,332 @@
+import abc
+from collections.abc import Sequence
+import dataclasses
+import enum
+import logging
+import pathlib
+from typing import Generic, TypeVar
+
+import augmax
+from flax import nnx
+from flax import struct
+from flax import traverse_util
+import jax
+import jax.numpy as jnp
+import numpy as np
+import orbax.checkpoint as ocp
+import safetensors
+import torch
+
+from openpi.models_pytorch import pi0_pytorch
+from openpi.shared import image_tools
+import openpi.shared.array_typing as at
+
+logger = logging.getLogger("openpi")
+
+# Type variable for array types (JAX arrays, PyTorch tensors, or numpy arrays)
+ArrayT = TypeVar("ArrayT", bound=jax.Array | torch.Tensor | np.ndarray)
+
+
+class ModelType(enum.Enum):
+    """Supported model types."""
+
+    PI0 = "pi0"
+    PI0_FAST = "pi0_fast"
+    PI05 = "pi05"
+
+
+# The model always expects these images
+IMAGE_KEYS = (
+    "base_0_rgb",
+    "left_wrist_0_rgb",
+    "right_wrist_0_rgb",
+)
+
+
+# This may need change if we release a small model.
+IMAGE_RESOLUTION = (224, 224)
+
+
+# Data format
+#
+# Data transforms produce the model input as a nested dictionary which is later converted
+# into `Obesrvation` and `Actions` objects. See below.
+#
+# In the dictory form, this data should look like:
+# {
+#     # Observation data.
+#     "image": {
+#         "base_0_rgb": (float32|uint8)[*b, h, w, 3],  # RGB image in [-1, 1] or [0, 255]
+#         ...  # Additional camera views
+#     },
+#     "image_mask": {
+#         "base_0_rgb": bool[*b],  # True if image is valid
+#         ...  # Masks for additional views
+#     },
+#     "state": float32[*b, s],  # Low-dimensional robot state
+#     "tokenized_prompt": int32[*b, l],  # Optional, tokenized language prompt
+#     "tokenized_prompt_mask": bool[*b, l],  # Optional, mask for tokenized prompt
+#     "token_ar_mask": int32[*b, l],  # Optional, autoregressive mask for FAST model
+#     "token_loss_mask": bool[*b, l],  # Optional, loss mask for FAST model
+#
+#      # Actions data.
+#      "actions": float32[*b ah ad]
+# }
+# where:
+#   *b = batch dimensions
+#   h,w = image height/width
+#   s = state dimension
+#   l = sequence length
+#
+@at.typecheck
+@struct.dataclass
+class Observation(Generic[ArrayT]):
+    """Holds observations, i.e., inputs to the model.
+
+    See `Observation.from_dict` to see the expected dictionary form. This is the format
+    that should be produced by the data transforms.
+    """
+
+    # Images, in [-1, 1] float32.
+    images: dict[str, at.Float[ArrayT, "*b h w c"]]
+    # Image masks, with same keys as images.
+    image_masks: dict[str, at.Bool[ArrayT, "*b"]]
+    # Low-dimensional robot state.
+    state: at.Float[ArrayT, "*b s"]
+
+    # Tokenized prompt.
+    tokenized_prompt: at.Int[ArrayT, "*b l"] | None = None
+    # Tokenized prompt mask.
+    tokenized_prompt_mask: at.Bool[ArrayT, "*b l"] | None = None
+
+    # pi0-fast model specific fields.
+
+    # Token auto-regressive mask (for FAST autoregressive model).
+    token_ar_mask: at.Int[ArrayT, "*b l"] | None = None
+    # Token loss mask (for FAST autoregressive model).
+    token_loss_mask: at.Bool[ArrayT, "*b l"] | None = None
+
+    @classmethod
+    def from_dict(cls, data: at.PyTree[ArrayT]) -> "Observation[ArrayT]":
+        """This method defines the mapping between unstructured data (i.e., nested dict) to the structured Observation format."""
+        # Ensure that tokenized_prompt and tokenized_prompt_mask are provided together.
+        if ("tokenized_prompt" in data) != ("tokenized_prompt_mask" in data):
+            raise ValueError("tokenized_prompt and tokenized_prompt_mask must be provided together.")
+        # If images are uint8, convert them to [-1, 1] float32.
+        for key in data["image"]:
+            if data["image"][key].dtype == np.uint8:
+                data["image"][key] = data["image"][key].astype(np.float32) / 255.0 * 2.0 - 1.0
+            elif hasattr(data["image"][key], "dtype") and data["image"][key].dtype == torch.uint8:
+                data["image"][key] = data["image"][key].to(torch.float32).permute(0, 3, 1, 2) / 255.0 * 2.0 - 1.0
+        return cls(
+            images=data["image"],
+            image_masks=data["image_mask"],
+            state=data["state"],
+            tokenized_prompt=data.get("tokenized_prompt"),
+            tokenized_prompt_mask=data.get("tokenized_prompt_mask"),
+            token_ar_mask=data.get("token_ar_mask"),
+            token_loss_mask=data.get("token_loss_mask"),
+        )
+
+    def to_dict(self) -> at.PyTree[ArrayT]:
+        """Convert the Observation to a nested dict."""
+        result = dataclasses.asdict(self)
+        result["image"] = result.pop("images")
+        result["image_mask"] = result.pop("image_masks")
+        return result
+
+
+# Defines the format of the actions. This field is included as "actions" inside the dictionary
+# produced by the data transforms.
+Actions = at.Float[ArrayT, "*b ah ad"]
+
+
+def preprocess_observation(
+    rng: at.KeyArrayLike | None,
+    observation: Observation,
+    *,
+    train: bool = False,
+    image_keys: Sequence[str] = IMAGE_KEYS,
+    image_resolution: tuple[int, int] = IMAGE_RESOLUTION,
+) -> Observation:
+    """Preprocess the observations by performing image augmentations (if train=True), resizing (if necessary), and
+    filling in a default image mask (if necessary).
+    """
+
+    if not set(image_keys).issubset(observation.images):
+        raise ValueError(f"images dict missing keys: expected {image_keys}, got {list(observation.images)}")
+
+    batch_shape = observation.state.shape[:-1]
+
+    out_images = {}
+    for key in image_keys:
+        image = observation.images[key]
+        if image.shape[1:3] != image_resolution:
+            logger.info(f"Resizing image {key} from {image.shape[1:3]} to {image_resolution}")
+            image = image_tools.resize_with_pad(image, *image_resolution)
+
+        if train:
+            # Convert from [-1, 1] to [0, 1] for augmax.
+            image = image / 2.0 + 0.5
+
+            transforms = []
+            if "wrist" not in key:
+                height, width = image.shape[1:3]
+                transforms += [
+                    augmax.RandomCrop(int(width * 0.95), int(height * 0.95)),
+                    augmax.Resize(width, height),
+                    augmax.Rotate((-5, 5)),
+                ]
+            transforms += [
+                augmax.ColorJitter(brightness=0.3, contrast=0.4, saturation=0.5),
+            ]
+            sub_rngs = jax.random.split(rng, image.shape[0])
+            image = jax.vmap(augmax.Chain(*transforms))(sub_rngs, image)
+
+            # Back to [-1, 1].
+            image = image * 2.0 - 1.0
+
+        out_images[key] = image
+
+    # obtain mask
+    out_masks = {}
+    for key in out_images:
+        if key not in observation.image_masks:
+            # do not mask by default
+            out_masks[key] = jnp.ones(batch_shape, dtype=jnp.bool)
+        else:
+            out_masks[key] = jnp.asarray(observation.image_masks[key])
+
+    return Observation(
+        images=out_images,
+        image_masks=out_masks,
+        state=observation.state,
+        tokenized_prompt=observation.tokenized_prompt,
+        tokenized_prompt_mask=observation.tokenized_prompt_mask,
+        token_ar_mask=observation.token_ar_mask,
+        token_loss_mask=observation.token_loss_mask,
+    )
+
+
+@dataclasses.dataclass(frozen=True)
+class BaseModelConfig(abc.ABC):
+    """Configuration shared by all models. Specific models should inherit from this class, and implement the `create`
+    method to create the corresponding model.
+    """
+
+    # Action space dimension.
+    action_dim: int
+    # Action sequence length.
+    action_horizon: int
+    # Tokenized prompt maximum length.
+    max_token_len: int
+
+    @property
+    @abc.abstractmethod
+    def model_type(self) -> ModelType:
+        """The model type."""
+
+    @abc.abstractmethod
+    def create(self, rng: at.KeyArrayLike) -> "BaseModel":
+        """Create a new model, initializing parameters."""
+
+    def load(self, params: at.Params, *, remove_extra_params: bool = True) -> "BaseModel":
+        """Create a model with the given parameters."""
+        model = nnx.eval_shape(self.create, jax.random.key(0))
+        graphdef, state = nnx.split(model)
+        if remove_extra_params:
+            params = ocp.transform_utils.intersect_trees(state.to_pure_dict(), params)
+        at.check_pytree_equality(expected=state.to_pure_dict(), got=params, check_shapes=True, check_dtypes=False)
+        state.replace_by_pure_dict(params)
+        return nnx.merge(graphdef, state)
+
+    def load_pytorch(self, train_config, weight_path: str):
+        logger.info(f"train_config: {train_config}")
+        model = pi0_pytorch.PI0Pytorch(config=train_config.model)
+        safetensors.torch.load_model(model, weight_path)
+        return model
+
+    @abc.abstractmethod
+    def inputs_spec(self, *, batch_size: int = 1) -> tuple[Observation, Actions]:
+        """Returns the input specification for the model. Values are jax.ShapeDtypeStruct."""
+
+    def fake_obs(self, batch_size: int = 1) -> Observation:
+        observation_spec, _ = self.inputs_spec(batch_size=batch_size)
+        return jax.tree.map(lambda x: jnp.ones(x.shape, x.dtype), observation_spec)
+
+    def fake_act(self, batch_size: int = 1) -> Actions:
+        _, action_spec = self.inputs_spec(batch_size=batch_size)
+        return jax.tree.map(lambda x: jnp.ones(x.shape, x.dtype), action_spec)
+
+
+@dataclasses.dataclass
+class BaseModel(nnx.Module, abc.ABC):
+    """Base class for all model implementations. Specific models should inherit from this class. They should call
+    super().__init__() to initialize the shared attributes (action_dim, action_horizon, and max_token_len).
+    """
+
+    action_dim: int
+    action_horizon: int
+    max_token_len: int
+
+    @abc.abstractmethod
+    def compute_loss(
+        self,
+        rng: at.KeyArrayLike,
+        observation: Observation,
+        actions: Actions,
+        *,
+        train: bool = False,
+    ) -> at.Float[at.Array, "*b ah"]: ...
+
+    @abc.abstractmethod
+    def sample_actions(self, rng: at.KeyArrayLike, observation: Observation, **kwargs) -> Actions: ...
+
+
+def restore_params(
+    params_path: pathlib.Path | str,
+    *,
+    restore_type: type[np.ndarray] | type[jax.Array] = jax.Array,
+    dtype: jnp.dtype | None = None,
+    sharding: jax.sharding.Sharding | None = None,
+) -> at.Params:
+    """Restores unstructured params PyTree from a checkpoint.
+
+    This works with checkpoints saved with `save_state` during openpi training (see `training/checkpoints.py`) as
+    well as pre-trained checkpoints released for openpi.
+
+    Args:
+        params_path: The local path to the checkpoint directory.
+        restore_type: The type to restore the params as. Can be set to `np.ndarray` to load the params as a numpy array.
+        dtype: The dtype to restore all params as. If not provided, will use the original dtype from the checkpoint.
+        sharding: The sharding to use for the params. If not provided, the params will be replicated across all devices.
+
+    Returns:
+        The restored params.
+    """
+    params_path = pathlib.Path(params_path).resolve() if not str(params_path).startswith("gs://") else params_path
+
+    if restore_type is jax.Array and sharding is None:
+        mesh = jax.sharding.Mesh(jax.devices(), ("x",))
+        sharding = jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec())
+
+    with ocp.PyTreeCheckpointer() as ckptr:
+        metadata = ckptr.metadata(params_path)
+        item = {"params": metadata["params"]}
+
+        params = ckptr.restore(
+            params_path,
+            ocp.args.PyTreeRestore(
+                item=item,
+                restore_args=jax.tree.map(
+                    lambda _: ocp.ArrayRestoreArgs(sharding=sharding, restore_type=restore_type, dtype=dtype), item
+                ),
+            ),
+        )["params"]
+
+    # If the params were saved with `save_state` during openpi training, every key path will end with "value", which is
+    # added by `nnx.State`. We remove the "value" suffix here and always return what NNX calls a "pure dict".
+    flat_params = traverse_util.flatten_dict(params)
+    if all(kp[-1] == "value" for kp in flat_params):
+        flat_params = {kp[:-1]: v for kp, v in flat_params.items()}
+    return traverse_util.unflatten_dict(flat_params)

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/pi0_fast.py

@@ -0,0 +1,313 @@
+import dataclasses
+import logging
+from typing import Any
+
+import einops
+import flax.nnx as nnx
+import flax.nnx.bridge as nnx_bridge
+import jax
+import jax.numpy as jnp
+from typing_extensions import override
+
+from openpi.models import model as _model
+import openpi.models.gemma_fast as _gemma
+import openpi.models.siglip as _siglip
+from openpi.shared import array_typing as at
+import openpi.shared.nnx_utils as nnx_utils
+
+logger = logging.getLogger("openpi")
+
+PALIGEMMA_EOS_TOKEN = 1
+
+
+def make_attn_mask(input_mask, mask_ar):
+    """Adapted from big_vision.
+
+    Tokens can attend to valid inputs tokens which have a cumulative mask_ar
+    smaller or equal to theirs. This way `mask_ar` bool[?B, N] can be used to
+    setup several types of attention, for example:
+
+      [[1 1 1 1 1 1]]: pure causal attention.
+
+      [[0 0 0 1 1 1]]: prefix-lm attention. The first 3 tokens can attend between
+          themselves and the last 3 tokens have a causal attention. The first
+          entry could also be a 1 without changing behaviour.
+
+      [[1 0 1 0 1 0 0 1 0 0]]: causal attention between 4 blocks. Tokens of a
+          block can attend all previous blocks and all tokens on the same block.
+
+    Args:
+      input_mask: bool[B, N] true if its part of the input, false if padding.
+      mask_ar: bool[?B, N] mask that's true where previous tokens cannot depend on
+        it and false where it shares the same attention mask as the previous token.
+    """
+    mask_ar = jnp.broadcast_to(mask_ar, input_mask.shape)
+    cumsum = jnp.cumsum(mask_ar, axis=1)
+    attn_mask = cumsum[:, None, :] <= cumsum[:, :, None]
+    valid_mask = input_mask[:, None, :] * input_mask[:, :, None]
+    return jnp.logical_and(attn_mask, valid_mask)
+
+
+@jax.vmap
+def left_to_right_align(x, input_mask, attn_mask):
+    """Converts input from left-align to right-aligned."""
+    # Due to vmap, this is operating in a single example (not batch level).
+    assert x.ndim == 2
+    assert input_mask.ndim == 1
+    assert attn_mask.ndim == 2
+    assert x.shape[0] == input_mask.shape[0]
+    assert attn_mask.shape[0] == attn_mask.shape[1], attn_mask.shape
+    seqlen = jnp.max(input_mask * jnp.arange(input_mask.shape[0])) + 1
+    x = jnp.roll(x, -seqlen, axis=0)
+    input_mask = jnp.roll(input_mask, -seqlen, axis=0)
+    attn_mask = jnp.roll(attn_mask, -seqlen, axis=(0, 1))
+    return x, input_mask, attn_mask
+
+
+def put_along_last_axis(arr, indices, values):
+    """Like np.put_along_axis(..., axis=-1), since jax is missing it."""
+    assert arr.ndim == indices.ndim == values.ndim, (arr.ndim, indices.ndim, values.ndim)
+    onehot = jax.nn.one_hot(indices, arr.shape[-1], dtype=values.dtype)
+    put_mask = jnp.einsum("...i,...in->...n", jnp.ones(values.shape, jnp.int32), onehot)
+    put_values = jnp.einsum("...i,...in->...n", values, onehot)
+    return jnp.where(put_mask, put_values, arr)
+
+
+@dataclasses.dataclass(frozen=True)
+class Pi0FASTConfig(_model.BaseModelConfig):
+    dtype: str = "bfloat16"
+    paligemma_variant: _gemma.Variant = "gemma_2b"
+
+    # Set the model specific defaults.
+    action_dim: int = 32
+    action_horizon: int = 32
+    max_token_len: int = 250
+
+    # Tokenizer for the fast model.
+    fast_model_tokenizer: Any | None = None
+    # Keyword arguments for the fast model tokenizer.
+    fast_model_tokenizer_kwargs: dict[str, Any] | None = None
+
+    @property
+    @override
+    def model_type(self) -> _model.ModelType:
+        return _model.ModelType.PI0_FAST
+
+    @override
+    def create(self, rng: at.KeyArrayLike) -> "Pi0FAST":
+        return Pi0FAST(self, rngs=nnx.Rngs(rng))
+
+    @override
+    def inputs_spec(self, *, batch_size: int = 1) -> tuple[_model.Observation, _model.Actions]:
+        image_spec = jax.ShapeDtypeStruct([batch_size, *_model.IMAGE_RESOLUTION, 3], jnp.float32)
+        image_mask_spec = jax.ShapeDtypeStruct([batch_size], jnp.bool_)
+
+        with at.disable_typechecking():
+            observation_spec = _model.Observation(
+                images={
+                    "base_0_rgb": image_spec,
+                    "base_1_rgb": image_spec,
+                    "wrist_0_rgb": image_spec,
+                },
+                image_masks={
+                    "base_0_rgb": image_mask_spec,
+                    "base_1_rgb": image_mask_spec,
+                    "wrist_0_rgb": image_mask_spec,
+                },
+                state=jax.ShapeDtypeStruct([batch_size, self.action_dim], jnp.float32),
+                tokenized_prompt=jax.ShapeDtypeStruct([batch_size, self.max_token_len], jnp.int32),
+                tokenized_prompt_mask=jax.ShapeDtypeStruct([batch_size, self.max_token_len], bool),
+                token_ar_mask=jax.ShapeDtypeStruct([batch_size, self.max_token_len], jnp.int32),
+                token_loss_mask=jax.ShapeDtypeStruct([batch_size, self.max_token_len], jnp.bool_),
+            )
+        action_spec = jax.ShapeDtypeStruct([batch_size, self.action_horizon, self.action_dim], jnp.float32)
+
+        return observation_spec, action_spec
+
+    def get_freeze_filter(self) -> nnx.filterlib.Filter:
+        """Returns the freeze filter based on the model config."""
+        if "lora" in self.paligemma_variant:
+            return nnx.All(nnx_utils.PathRegex(".*llm.*"), nnx.Not(nnx_utils.PathRegex(".*lora.*")))
+        return nnx.Nothing
+
+
+class Pi0FAST(_model.BaseModel):
+    def __init__(self, config: Pi0FASTConfig, rngs: nnx.Rngs):
+        super().__init__(config.action_dim, config.action_horizon, config.max_token_len)
+        paligemma_config = _gemma.get_config(config.paligemma_variant)
+        # TODO: rewrite gemma in NNX. For now, use bridge.
+        llm = nnx_bridge.ToNNX(
+            _gemma.Module(
+                **paligemma_config,
+                embed_dtype=config.dtype,
+                cache_dtype=config.dtype,
+            )
+        )
+        llm.lazy_init(rngs=rngs, method="init")
+        img = nnx_bridge.ToNNX(
+            _siglip.Module(
+                num_classes=paligemma_config.width,
+                variant="So400m/14",
+                pool_type="none",
+                scan=True,
+                dtype_mm=config.dtype,
+            )
+        )
+        img.lazy_init(next(iter(config.fake_obs().images.values())), train=False, rngs=rngs)
+        self.PaliGemma = nnx.Dict(llm=llm, img=img)
+
+    @at.typecheck
+    def embed_inputs(
+        self, obs: _model.Observation
+    ) -> tuple[at.Float[at.Array, "b s emb"], at.Bool[at.Array, "b s"], at.Int[at.Array, "b s"]]:
+        input_mask = []
+        ar_mask = []
+        token_embeddings = []
+        # embed images
+        for name in obs.images:
+            image_token_embeddings, _ = self.PaliGemma.img(obs.images[name], train=False)
+
+            token_embeddings.append(image_token_embeddings)
+            input_mask.append(
+                einops.repeat(
+                    obs.image_masks[name],
+                    "b -> b s",
+                    s=image_token_embeddings.shape[1],
+                )
+            )
+            # image tokens attend to each other --> AR mask = 0
+            ar_mask.append(0 * input_mask[-1])
+
+        # add tokenized inputs
+        assert obs.tokenized_prompt is not None, "Tokenized prompt is required"
+        assert obs.tokenized_prompt_mask is not None, "Tokenized prompt mask is required"
+        assert obs.token_ar_mask is not None, "Token auto-regressive mask is required"
+        tokenized_inputs_embeddings = self.PaliGemma.llm(obs.tokenized_prompt, embed_only=True)
+        token_embeddings.append(tokenized_inputs_embeddings)
+        input_mask.append(obs.tokenized_prompt_mask)
+        ar_mask.append(obs.token_ar_mask)
+
+        # return embeddings, input mask, and ar mask
+        return (
+            jnp.concatenate(token_embeddings, axis=1),
+            jnp.concatenate(input_mask, axis=1),
+            jnp.concatenate(ar_mask, axis=1),
+        )
+
+    @override
+    def compute_loss(
+        self, rng: at.KeyArrayLike, observation: _model.Observation, actions: _model.Actions, *, train: bool = False
+    ) -> at.Float[at.Array, "*b ah"]:
+        observation = _model.preprocess_observation(
+            rng, observation, train=train, image_keys=list(observation.images.keys())
+        )
+
+        # Compute inputs: one big forward pass of prefix + suffix at once
+        input_token_embeddings, input_mask, ar_mask = self.embed_inputs(observation)
+        attn_mask = make_attn_mask(input_mask, ar_mask)
+
+        # Compute one-hot targets: we predict *next* token, so shift the input tokens by one.
+        targets = jax.nn.one_hot(
+            observation.tokenized_prompt[:, 1:],
+            self.PaliGemma.llm.module.vocab_size,
+        )
+
+        # Each input predicts *next* token, so we don't input the last token.
+        pre_logits, _, _ = self.PaliGemma.llm(
+            embedded_prefix=input_token_embeddings[:, :-1],
+            mask=attn_mask[:, :-1, :-1],
+            return_prelogits=True,
+        )
+
+        # Only decode logits for the target tokens to save memory
+        # (decoding matmul is large because it is a seq_len x vocab_size dense layer).
+        logits, _ = self.PaliGemma.llm(
+            pre_logits=pre_logits[:, -targets.shape[1] :],
+        )
+        logp = jax.nn.log_softmax(logits, axis=-1)
+
+        # Compute CE loss on token targets
+        assert observation.token_loss_mask is not None, "Token loss mask is required"
+        loss_mask = observation.token_loss_mask[:, 1:]
+        token_pplx = jnp.sum(targets * logp, axis=-1)
+        return -jnp.sum(token_pplx * loss_mask, axis=-1) / jnp.clip(jnp.sum(loss_mask, -1), 1)
+
+    @override
+    def sample_actions(
+        self,
+        rng: at.KeyArrayLike,
+        observation: _model.Observation,
+        *,
+        max_decoding_steps: int | at.Int[at.Array, ""] = 256,
+        temperature: float = 0.0,
+    ) -> _model.Actions:
+        # TODO: this is a hack to get the image keys.
+        observation = _model.preprocess_observation(
+            None, observation, train=False, image_keys=list(observation.images.keys())
+        )
+
+        # embed inputs
+        prefix_token_embeddings, prefix_mask, prefix_ar_mask = self.embed_inputs(observation)
+        prefix_attn_mask = make_attn_mask(prefix_mask, prefix_ar_mask)
+
+        # left to right align all input token sequences
+        prefix_token_embeddings, prefix_mask, prefix_attn_mask = left_to_right_align(
+            prefix_token_embeddings, prefix_mask, prefix_attn_mask
+        )
+        prefill_size = prefix_token_embeddings.shape[1]
+        prefill_len = jnp.sum(prefix_mask, axis=-1)
+        prefix_start = prefill_size - prefill_len
+
+        # first fill KV cache with a forward pass of the prefix
+        # pad attention mask to set the size of the KV cache (prefill_size + max_decoding_steps)
+        prefix_attn_mask = jnp.pad(prefix_attn_mask, ((0, 0), (0, 0), (0, max_decoding_steps)))
+        prefix_positions = jnp.cumsum(prefix_mask, axis=-1) - 1
+        prefix_logits, kv_cache, _ = self.PaliGemma.llm(
+            embedded_prefix=prefix_token_embeddings, mask=prefix_attn_mask, positions=prefix_positions, decode=True
+        )
+
+        # prepare decoding -- final logit decodes the first token
+        last_logit = prefix_logits[:, -1:]
+        output_tokens = jnp.zeros((last_logit.shape[0], max_decoding_steps))
+
+        def step(carry):
+            rng, last_logit, output_tokens, cache, _, step = carry
+
+            # Sample token from last logit
+            # Split RNG for this step
+            rng, rng_step = jax.random.split(rng)
+            token = jax.lax.cond(
+                temperature > 0.0,
+                lambda _: jax.random.categorical(rng_step, last_logit / temperature, axis=-1),
+                lambda _: jnp.argmax(last_logit, axis=-1),
+                operand=None,
+            )
+            output_tokens = put_along_last_axis(output_tokens, jnp.broadcast_to(step, (token.shape[0], 1)), token)
+
+            # Check for early stopping --> stop if all batch elements have EOS token
+            has_eos = jnp.any(token == PALIGEMMA_EOS_TOKEN, axis=-1)
+            all_eos = jnp.all(has_eos)
+
+            # Decode one step
+            token_embedding = self.PaliGemma.llm(token, embed_only=True)
+            positions = prefill_len[:, None] + step + 1
+            mask = jnp.logical_and(
+                jnp.arange(prefill_size + max_decoding_steps)[None, None, :] >= prefix_start[:, None, None],
+                jnp.arange(prefill_size + max_decoding_steps)[None, None, :]
+                < (jnp.broadcast_to(prefill_size + step + 1, (prefix_start.shape[0], 1, 1))),
+            )
+            last_logit, kv_cache, _ = self.PaliGemma.llm(
+                embedded_prefix=token_embedding, mask=mask, positions=positions, decode=True, kv_cache=cache
+            )
+
+            return rng, last_logit, output_tokens, kv_cache, all_eos, step + 1
+
+        def cond(carry):
+            _, _, _, _, all_eos, step = carry
+            return (~all_eos) & (step < max_decoding_steps)
+
+        # Use lax.while_loop so we can jit the full decoding loop.
+        _, _, output_tokens, _, _, _ = jax.lax.while_loop(
+            cond, step, (rng, last_logit, output_tokens, kv_cache, False, 0)
+        )
+        return output_tokens

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/pi0_test.py

@@ -0,0 +1,46 @@
+import flax.nnx as nnx
+import jax
+
+import openpi.models.pi0_config as _pi0_config
+
+
+def _get_frozen_state(config: _pi0_config.Pi0Config) -> nnx.State:
+    abstract_model = nnx.eval_shape(config.create, jax.random.key(0))
+
+    freeze_filter = config.get_freeze_filter()
+    return nnx.state(abstract_model, nnx.All(nnx.Param, freeze_filter)).flat_state()
+
+
+def test_pi0_full_finetune():
+    config = _pi0_config.Pi0Config()
+    state = _get_frozen_state(config)
+    assert len(state) == 0
+
+
+def test_pi0_gemma_lora():
+    config = _pi0_config.Pi0Config(paligemma_variant="gemma_2b_lora")
+    state = _get_frozen_state(config)
+    assert len(state) == 9
+    assert all("lora" not in p for p in state)
+    assert all("llm" in p for p in state)
+    assert all("_1" not in p for p in state)
+
+
+def test_pi0_action_expert_lora():
+    config = _pi0_config.Pi0Config(action_expert_variant="gemma_300m_lora")
+    state = _get_frozen_state(config)
+    # excluding embedder, rest of the params should be same as gemma_lora.
+    assert len(state) == 8
+    assert all("lora" not in p for p in state)
+    assert all("llm" in p for p in state)
+    # all frozen params should have _1 in their path since it's the action expert.
+    assert all(any("_1" in p for p in path) for path in state)
+
+
+def test_pi0_all_lora():
+    config = _pi0_config.Pi0Config(paligemma_variant="gemma_2b_lora", action_expert_variant="gemma_300m_lora")
+    state = _get_frozen_state(config)
+    # sum of gemma_lora and action_expert_lora's frozen params.
+    assert len(state) == 17
+    assert all("lora" not in p for p in state)
+    assert all("llm" in p for p in state)

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/siglip.py

@@ -0,0 +1,373 @@
+# Copyright 2024 Big Vision Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""A refactored and simplified ViT adoptation for Pi, taken from big_vision."""
+
+from collections.abc import Sequence
+
+import flax.linen as nn
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+import openpi.training.sharding as sharding
+
+
+def posemb_sincos_2d(h, w, width, temperature=10_000.0, dtype=jnp.float32):
+    """Follows the MoCo v3 logic."""
+    y, x = jnp.mgrid[:h, :w]
+
+    assert width % 4 == 0, "Width must be mult of 4 for sincos posemb"
+    omega = jnp.arange(width // 4) / (width // 4 - 1)
+    omega = 1.0 / (temperature**omega)
+    y = jnp.einsum("m,d->md", y.flatten(), omega)
+    x = jnp.einsum("m,d->md", x.flatten(), omega)
+    pe = jnp.concatenate([jnp.sin(x), jnp.cos(x), jnp.sin(y), jnp.cos(y)], axis=1)
+    return jnp.asarray(pe, dtype)[None, :, :]
+
+
+def get_posemb(self, typ, seqshape, width, name, dtype=jnp.float32):
+    if typ == "learn":
+        return self.param(
+            name,
+            nn.initializers.normal(stddev=1 / np.sqrt(width)),
+            (1, np.prod(seqshape), width),
+            dtype,
+        )
+    if typ == "sincos2d":
+        return posemb_sincos_2d(*seqshape, width, dtype=dtype)
+    raise ValueError(f"Unknown posemb type: {typ}")
+
+
+class MlpBlock(nn.Module):
+    """Transformer MLP / feed-forward block."""
+
+    mlp_dim: int | None = None  # Defaults to 4x input dim
+    dropout: float = 0.0
+    dtype_mm: str = "float32"
+
+    @nn.compact
+    def __call__(self, x, deterministic=True):  # noqa: FBT002
+        """Applies Transformer MlpBlock module."""
+        inits = {
+            "kernel_init": nn.initializers.xavier_uniform(),
+            "bias_init": nn.initializers.normal(stddev=1e-6),
+        }
+
+        _, _, d = x.shape  # n,l,d
+        x = nn.Dense(self.mlp_dim or 4 * d, dtype=self.dtype_mm, **inits)(x)
+        x = nn.gelu(x)
+        x = nn.Dropout(rate=self.dropout)(x, deterministic)
+        return nn.Dense(d, dtype=self.dtype_mm, **inits)(x)
+
+
+class Encoder1DBlock(nn.Module):
+    """Single transformer encoder block (MHSA + MLP)."""
+
+    mlp_dim: int | None = None  # Defaults to 4x input dim
+    num_heads: int = 12
+    dropout: float = 0.0
+    dtype_mm: str = "float32"
+
+    @nn.compact
+    def __call__(self, x, deterministic=True):  # noqa: FBT002
+        out = {}
+        x = sharding.activation_sharding_constraint(x)
+        y = nn.LayerNorm(dtype=self.dtype_mm)(x)
+        y = out["sa"] = nn.MultiHeadDotProductAttention(
+            num_heads=self.num_heads,
+            kernel_init=nn.initializers.xavier_uniform(),
+            deterministic=deterministic,
+            dtype=self.dtype_mm,
+        )(y, y)
+        y = sharding.activation_sharding_constraint(y)
+        y = nn.Dropout(rate=self.dropout)(y, deterministic)
+        x = out["+sa"] = x + y
+
+        y = nn.LayerNorm(dtype=self.dtype_mm)(x)
+        y = out["mlp"] = MlpBlock(
+            mlp_dim=self.mlp_dim,
+            dropout=self.dropout,
+            dtype_mm=self.dtype_mm,
+        )(y, deterministic)
+        y = sharding.activation_sharding_constraint(y)
+        y = nn.Dropout(rate=self.dropout)(y, deterministic)
+        x = out["+mlp"] = x + y
+        x = sharding.activation_sharding_constraint(x)
+        return x, out
+
+
+class Encoder(nn.Module):
+    """Transformer Model Encoder for sequence to sequence translation."""
+
+    depth: int
+    mlp_dim: int | None = None  # Defaults to 4x input dim
+    num_heads: int = 12
+    dropout: float = 0.0
+    scan: bool = False
+    remat_policy: str = "nothing_saveable"
+    dtype_mm: str = "float32"
+
+    @nn.compact
+    def __call__(self, x, deterministic=True):  # noqa: FBT002
+        out = {}
+
+        if self.scan:
+            block = nn.remat(
+                Encoder1DBlock,
+                prevent_cse=False,
+                static_argnums=(2,),  # 0=self, 2=deterministic
+                policy=getattr(jax.checkpoint_policies, self.remat_policy, None),
+            )
+            x, scan_out = nn.scan(
+                block,
+                variable_axes={"params": 0},
+                split_rngs={"params": True, "dropout": True},
+                in_axes=nn.broadcast,
+                length=self.depth,
+            )(
+                name="encoderblock",
+                dtype_mm=self.dtype_mm,
+                mlp_dim=self.mlp_dim,
+                num_heads=self.num_heads,
+                dropout=self.dropout,
+            )(x, deterministic)
+            for lyr in range(self.depth):
+                out[f"block{lyr:02d}"] = jax.tree.map(lambda o, lyr=lyr: o[lyr], scan_out)
+        else:
+            # Input Encoder
+            for lyr in range(self.depth):
+                block_cur = Encoder1DBlock(
+                    name=f"encoderblock_{lyr}",
+                    dtype_mm=self.dtype_mm,
+                    mlp_dim=self.mlp_dim,
+                    num_heads=self.num_heads,
+                    dropout=self.dropout,
+                )
+                x, out[f"block{lyr:02d}"] = block_cur(x, deterministic)
+            out["pre_ln"] = x  # Alias for last block, but without the number in it.
+
+        return nn.LayerNorm(name="encoder_norm", dtype=self.dtype_mm)(x), out
+
+
+class MAPHead(nn.Module):
+    """Multihead Attention Pooling."""
+
+    mlp_dim: int | None = None  # Defaults to 4x input dim
+    num_heads: int = 12
+    dtype_mm: str = "float32"
+
+    @nn.compact
+    def __call__(self, x):
+        n, _, d = x.shape  # n,l,d
+        probe = self.param("probe", nn.initializers.xavier_uniform(), (1, 1, d), x.dtype)
+        probe = jnp.tile(probe, [n, 1, 1])
+
+        x = nn.MultiHeadDotProductAttention(
+            num_heads=self.num_heads,
+            dtype=self.dtype_mm,
+            kernel_init=nn.initializers.xavier_uniform(),
+        )(probe, x)
+
+        y = nn.LayerNorm(dtype=self.dtype_mm)(x)
+        x = x + MlpBlock(mlp_dim=self.mlp_dim, dtype=self.dtype_mm)(y)
+        return x[:, 0]
+
+
+class _Module(nn.Module):
+    """ViT model."""
+
+    num_classes: int | None = None
+    patch_size: Sequence[int] = (16, 16)
+    width: int = 768
+    depth: int = 12
+    mlp_dim: int | None = None  # Defaults to 4x input dim
+    num_heads: int = 12
+    posemb: str = "learn"  # Can also be "sincos2d"
+    rep_size: int | bool = False
+    dropout: float = 0.0
+    pool_type: str = "gap"  # Can also be "map" or "tok"
+    head_zeroinit: bool = True
+    scan: bool = False
+    # or "dots_with_no_batch_dims_saveable" for more speed (memory costly)
+    remat_policy: str = "nothing_saveable"
+    dtype_mm: str = "float32"
+
+    @nn.compact
+    def __call__(self, image, *, train=False):
+        out = {}
+
+        # Kevin edit: do patch extraction and posemb in float32,
+        # because I feel like it's a bit safer.
+        image = jnp.asarray(image, jnp.float32)
+
+        # Patch extraction
+        x = out["stem"] = nn.Conv(
+            self.width,
+            self.patch_size,
+            strides=self.patch_size,
+            padding="VALID",
+            name="embedding",
+            dtype=jnp.float32,
+        )(image)
+
+        n, h, w, c = x.shape
+        x = jnp.reshape(x, [n, h * w, c])
+
+        # Add posemb before adding extra token.
+        x = out["with_posemb"] = x + get_posemb(self, self.posemb, (h, w), c, "pos_embedding", jnp.float32)
+
+        if self.pool_type == "tok":
+            cls = self.param("cls", nn.initializers.zeros, (1, 1, c), x.dtype)
+            x = jnp.concatenate([jnp.tile(cls, [n, 1, 1]), x], axis=1)
+
+        n, _, c = x.shape  # n,l,d
+        x = nn.Dropout(rate=self.dropout)(x, not train)
+
+        # Kevin edit: now cast back to dtype_mm (potentially half precision)
+        x = x.astype(self.dtype_mm)
+
+        x, out["encoder"] = Encoder(
+            depth=self.depth,
+            mlp_dim=self.mlp_dim,
+            num_heads=self.num_heads,
+            dropout=self.dropout,
+            scan=self.scan,
+            remat_policy=self.remat_policy,
+            dtype_mm=self.dtype_mm,
+            name="Transformer",
+        )(x, deterministic=not train)
+        encoded = out["encoded"] = x
+
+        if self.pool_type == "map":
+            x = out["head_input"] = MAPHead(
+                num_heads=self.num_heads,
+                mlp_dim=self.mlp_dim,
+                dtype=self.dtype_mm,
+            )(x)
+        elif self.pool_type == "gap":
+            x = out["head_input"] = jnp.mean(x, axis=1)
+        elif self.pool_type == "0":
+            x = out["head_input"] = x[:, 0]
+        elif self.pool_type == "tok":
+            x = out["head_input"] = x[:, 0]
+            encoded = encoded[:, 1:]
+        elif self.pool_type == "none":
+            pass
+        else:
+            raise ValueError(f"Unknown pool type: '{self.pool_type}'")
+
+        x_2d = jnp.reshape(encoded, [n, h, w, -1])
+
+        if self.rep_size:
+            rep_size = self.width if self.rep_size is True else self.rep_size
+            hid = nn.Dense(rep_size, dtype=self.dtype_mm, name="pre_logits")
+            # NOTE: In the past we did not include tanh in pre_logits.
+            # For few-shot, it should not matter much, as it whitens anyways.
+            x_2d = nn.tanh(hid(x_2d))
+            x = nn.tanh(hid(x))
+
+        out["pre_logits_2d"] = x_2d
+        out["pre_logits"] = x
+
+        if self.num_classes:
+            kw = {"kernel_init": nn.initializers.zeros} if self.head_zeroinit else {}
+            head = nn.Dense(self.num_classes, dtype=self.dtype_mm, name="head", **kw)
+            x_2d = out["logits_2d"] = head(x_2d)
+            x = out["logits"] = head(x)
+
+        return x, out
+
+
+def Module(num_classes=None, *, variant=None, **kw):  # pylint: disable=invalid-name  # noqa: N802
+    """Factory function, because linen really don't like what I'm doing!"""
+    return _Module(num_classes, **{**decode_variant(variant), **kw})
+
+
+def decode_variant(variant):
+    """Converts a string like "B" or "B/32" into a params dict."""
+    if variant is None:
+        return {}
+
+    v, patch = variant, {}
+    if "/" in variant:
+        v, patch = variant.split("/")
+        patch = {"patch_size": (int(patch), int(patch))}
+
+    return {
+        # pylint:disable=line-too-long
+        # Reference: Table 2 of https://arxiv.org/abs/2106.04560.
+        "width": {
+            "mu": 32,
+            "Ti": 192,
+            "S": 384,
+            "M": 512,
+            "B": 768,
+            "L": 1024,
+            "So400m": 1152,
+            "H": 1280,
+            "g": 1408,
+            "g-opt": 1536,
+            "G": 1664,
+            "G-opt": 1536,
+            "e": 1792,
+        }[v],
+        "depth": {
+            "mu": 1,
+            "Ti": 12,
+            "S": 12,
+            "M": 12,
+            "B": 12,
+            "L": 24,
+            "So400m": 27,
+            "H": 32,
+            "g": 40,
+            "g-opt": 40,
+            "G": 48,
+            "G-opt": 48,
+            "e": 56,
+        }[v],
+        "mlp_dim": {
+            "mu": 128,
+            "Ti": 768,
+            "S": 1536,
+            "M": 2048,
+            "B": 3072,
+            "L": 4096,
+            "So400m": 4304,
+            "H": 5120,
+            "g": 6144,
+            "g-opt": 6144,
+            "G": 8192,
+            "G-opt": 8192,
+            "e": 15360,
+        }[v],
+        "num_heads": {
+            "mu": 2,
+            "Ti": 3,
+            "S": 6,
+            "M": 8,
+            "B": 12,
+            "L": 16,
+            "So400m": 16,
+            "H": 16,
+            "g": 16,
+            "g-opt": 16,
+            "G": 16,
+            "G-opt": 16,
+            "e": 16,
+        }[v],
+        # pylint:enable=line-too-long
+        **patch,
+    }

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/tokenizer.py

@@ -0,0 +1,371 @@
+import logging
+import os
+
+import jax
+import numpy as np
+import orbax.checkpoint as ocp
+import sentencepiece
+from transformers import AutoProcessor
+
+import openpi.models.utils.fsq_tokenizer as fsq_tokenizer
+import openpi.shared.download as download
+
+
+class PaligemmaTokenizer:
+    def __init__(self, max_len: int = 48):
+        self._max_len = max_len
+
+        path = download.maybe_download("gs://big_vision/paligemma_tokenizer.model", gs={"token": "anon"})
+        with path.open("rb") as f:
+            self._tokenizer = sentencepiece.SentencePieceProcessor(model_proto=f.read())
+
+    def tokenize(self, prompt: str, state: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray]:
+        cleaned_text = prompt.strip().replace("_", " ").replace("\n", " ")
+        if state is not None:
+            # This is the Pi05 format, where the state is part of the discrete language input.
+            discretized_state = np.digitize(state, bins=np.linspace(-1, 1, 256 + 1)[:-1]) - 1
+            state_str = " ".join(map(str, discretized_state))
+            full_prompt = f"Task: {cleaned_text}, State: {state_str};\nAction: "
+            tokens = self._tokenizer.encode(full_prompt, add_bos=True)
+        else:
+            # This is the Pi0 format, where the state is part of the continuous action expert input.
+            # tokenize "\n" separately as the "start of answer" token
+            tokens = self._tokenizer.encode(cleaned_text, add_bos=True) + self._tokenizer.encode("\n")
+        tokens_len = len(tokens)
+        if tokens_len < self._max_len:
+            padding = [False] * (self._max_len - tokens_len)
+            mask = [True] * tokens_len + padding
+            tokens = tokens + padding
+        else:
+            if len(tokens) > self._max_len:
+                logging.warning(
+                    f"Token length ({len(tokens)}) exceeds max length ({self._max_len}), truncating. "
+                    "Consider increasing the `max_token_len` in your model config if this happens frequently."
+                )
+            tokens = tokens[: self._max_len]
+            mask = [True] * self._max_len
+
+        return np.asarray(tokens), np.asarray(mask)
+
+
+class FASTTokenizer:
+    def __init__(self, max_len: int = 256, fast_tokenizer_path: str = "physical-intelligence/fast"):
+        self._max_len = max_len
+
+        # Download base PaliGemma tokenizer
+        path = download.maybe_download("gs://big_vision/paligemma_tokenizer.model", gs={"token": "anon"})
+        with path.open("rb") as f:
+            self._paligemma_tokenizer = sentencepiece.SentencePieceProcessor(model_proto=f.read())
+
+        # Instantiate FAST tokenizer
+        self._fast_tokenizer = AutoProcessor.from_pretrained(fast_tokenizer_path, trust_remote_code=True)
+        self._fast_skip_tokens = 128  # Skip last 128 tokens in PaliGemma vocab since they are special tokens
+
+    def tokenize(
+        self, prompt: str, state: np.ndarray, actions: np.ndarray | None
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        cleaned_text = prompt.lower().strip().replace("_", " ")
+
+        # Convention: state gets discretized into 256 discrete bins (assumed range after normalization: [-1, 1])
+        discretized_state = np.digitize(state, bins=np.linspace(-1, 1, 256 + 1)[:-1]) - 1
+
+        # Convention: prefix includes prompt and string-representation of state, followed by ';'
+        state_str = " ".join(map(str, discretized_state))
+        prefix = f"Task: {cleaned_text}, State: {state_str};\n"
+        prefix_tokens = self._paligemma_tokenizer.encode(prefix, add_bos=True)
+
+        if actions is not None:
+            # Tokenize actions with FAST tokenizer --> map to last tokens in PaliGemma vocab
+            action_tokens = self._fast_tokenizer(actions[None])[0]
+            action_tokens_in_pg = self._act_tokens_to_paligemma_tokens(action_tokens)
+
+            # Convention: postfix contains 'Action:' followed by FAST tokens, followed by '|'
+            postfix_tokens = (
+                self._paligemma_tokenizer.encode("Action: ")
+                + action_tokens_in_pg.tolist()
+                + self._paligemma_tokenizer.encode("|", add_eos=True)
+            )
+        else:
+            postfix_tokens = []
+
+        # Create output token sequence & masks
+        # AR mask is 0 on prefix (bidirectional attention) and 1 on postfix (causal attention to all previous tokens)
+        tokens = prefix_tokens + postfix_tokens
+        token_mask = [True] * len(tokens)
+        ar_mask = [0] * len(prefix_tokens) + [1] * len(postfix_tokens)
+        loss_mask = [False] * len(prefix_tokens) + [True] * len(postfix_tokens)  # Loss on postfix only
+
+        # Pad tokens to max length
+        tokens_len = len(tokens)
+        if tokens_len < self._max_len:
+            padding = [False] * (self._max_len - tokens_len)
+            tokens = tokens + padding
+            token_mask = token_mask + padding
+            ar_mask = ar_mask + padding
+            loss_mask = loss_mask + padding
+        else:
+            if len(tokens) > self._max_len:
+                logging.warning(
+                    f"Token length ({len(tokens)}) exceeds max length ({self._max_len}), truncating. "
+                    "Consider increasing the `max_token_len` in your model config if this happens frequently."
+                )
+            tokens = tokens[: self._max_len]
+            token_mask = token_mask[: self._max_len]
+            ar_mask = ar_mask[: self._max_len]
+            loss_mask = loss_mask[: self._max_len]
+
+        return np.asarray(tokens), np.asarray(token_mask), np.asarray(ar_mask), np.asarray(loss_mask)
+
+    def extract_actions(self, tokens: np.ndarray, action_horizon: int, action_dim: int) -> np.ndarray:
+        # Decode predicted output tokens
+        decoded_tokens = self._paligemma_tokenizer.decode(tokens.tolist())
+
+        # Extract actions from FAST model outputs
+        if "Action: " not in decoded_tokens:
+            return np.zeros((action_horizon, action_dim), dtype=np.float32)
+
+        # Extract actions from decoded tokens
+        raw_action_tokens = np.array(
+            self._paligemma_tokenizer.encode(decoded_tokens.split("Action: ")[1].split("|")[0].strip())
+        )
+        action_tokens = self._act_tokens_to_paligemma_tokens(raw_action_tokens)
+        return self._fast_tokenizer.decode(
+            [action_tokens.tolist()], time_horizon=action_horizon, action_dim=action_dim
+        )[0]
+
+    def _act_tokens_to_paligemma_tokens(self, tokens: np.ndarray | list[int]) -> np.ndarray:
+        if isinstance(tokens, list):
+            tokens = np.array(tokens)
+        return self._paligemma_tokenizer.vocab_size() - 1 - self._fast_skip_tokens - tokens
+
+
+###########################################################################
+## The tokenizers below are used for RoboArena baseline implementations. ##
+## They are *not* used for pi0-style models.                             ##
+###########################################################################
+
+
+class BinningTokenizer:
+    """
+    Standard RT-2 / OpenVLA style binning tokenizer.
+    """
+
+    def __init__(self, max_len: int = 256, n_bins: int = 256):
+        self._max_len = max_len
+        self._n_bins = n_bins
+
+        # Download base PaliGemma tokenizer
+        path = download.maybe_download("gs://big_vision/paligemma_tokenizer.model", gs={"token": "anon"})
+        with path.open("rb") as f:
+            self._paligemma_tokenizer = sentencepiece.SentencePieceProcessor(model_proto=f.read())
+
+        self._fast_skip_tokens = 128  # Skip last 128 tokens in PaliGemma vocab since they are special tokens
+
+    def tokenize(
+        self, prompt: str, state: np.ndarray, actions: np.ndarray | None
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        """Tokenize a prompt and state into a sequence of tokens.
+
+        Args:
+            prompt: The text prompt to tokenize.
+            state: The state array to discretize and tokenize.
+            actions: Must be None. Action encoding is not currently supported.
+
+        Returns:
+            A tuple of (tokens, token_mask, ar_mask, targets).
+
+        Raises:
+            NotImplementedError: If actions is not None.
+        """
+        cleaned_text = prompt.lower().strip().replace("_", " ")
+
+        # Convention: state gets discretized into 256 discrete bins (assumed range after normalization: [-1, 1])
+        discretized_state = np.digitize(state, bins=np.linspace(-1, 1, 256 + 1)[:-1]) - 1
+
+        # Convention: prefix includes prompt and string-representation of state, followed by ';'
+        state_str = " ".join(map(str, discretized_state))
+        prefix = f"Task: {cleaned_text}, State: {state_str};\n"
+        prefix_tokens = self._paligemma_tokenizer.encode(prefix, add_bos=True)
+
+        if actions is not None:
+            raise NotImplementedError("BinningTokenizer does not support encoding actions atm (only for inference use)")
+        postfix_tokens = []
+
+        # Create output token sequence & masks
+        # AR mask is 0 on prefix (bidirectional attention) and 1 on postfix (causal attention to all previous tokens)
+        tokens = prefix_tokens + postfix_tokens
+        token_mask = [True] * len(tokens)
+        ar_mask = [0] * len(prefix_tokens) + [1] * len(postfix_tokens)
+        loss_mask = [False] * len(prefix_tokens) + [True] * len(postfix_tokens)  # Loss on postfix only
+
+        # Pad tokens to max length
+        tokens_len = len(tokens)
+        if tokens_len < self._max_len:
+            padding = [False] * (self._max_len - tokens_len)
+            tokens = tokens + padding
+            token_mask = token_mask + padding
+            ar_mask = ar_mask + padding
+            loss_mask = loss_mask + padding
+        else:
+            if len(tokens) > self._max_len:
+                logging.warning(
+                    f"Token length ({len(tokens)}) exceeds max length ({self._max_len}), truncating. "
+                    "Consider increasing the `max_token_len` in your model config if this happens frequently."
+                )
+            tokens = tokens[: self._max_len]
+            token_mask = token_mask[: self._max_len]
+            ar_mask = ar_mask[: self._max_len]
+            loss_mask = loss_mask[: self._max_len]
+
+        return np.asarray(tokens), np.asarray(token_mask), np.asarray(ar_mask), np.asarray(loss_mask)
+
+    def extract_actions(self, tokens: np.ndarray, action_horizon: int, action_dim: int) -> np.ndarray:
+        # Decode predicted output tokens
+        decoded_tokens = self._paligemma_tokenizer.decode(tokens.tolist())
+
+        # Extract actions from FAST model outputs
+        if "Action: " not in decoded_tokens:
+            return np.zeros((action_horizon, action_dim), dtype=np.float32)
+
+        # Extract actions from decoded tokens
+        raw_action_tokens = np.array(
+            self._paligemma_tokenizer.encode(decoded_tokens.split("Action: ")[1].split("|")[0].strip())
+        )
+        action_tokens = self._act_tokens_to_paligemma_tokens(raw_action_tokens)
+        if len(action_tokens) < action_horizon * action_dim:
+            return np.zeros([action_horizon, action_dim], dtype=np.float32)
+        action_tokens = action_tokens[: (action_horizon * action_dim)].reshape([action_horizon, action_dim])
+        return action_tokens / self._n_bins * 2 - 1
+
+    def _act_tokens_to_paligemma_tokens(self, tokens: np.ndarray | list[int]) -> np.ndarray:
+        if isinstance(tokens, list):
+            tokens = np.array(tokens)
+        return self._paligemma_tokenizer.vocab_size() - 1 - self._fast_skip_tokens - tokens
+
+
+class FSQTokenizer:
+    """
+    FSQ tokenizer from the FAST paper baselines.
+    """
+
+    def __init__(self, max_len: int = 256, fsq_tokenizer_path: str | None = None):
+        self._max_len = max_len
+
+        assert fsq_tokenizer_path is not None, "fsq_tokenizer_path must be provided"
+        # Download tokenizer
+        path = download.maybe_download(fsq_tokenizer_path)
+        tok_path = os.path.join(path, os.listdir(path)[0])
+
+        # Split step from path
+        step = int(tok_path.split("/")[-1])
+        base_path = tok_path.rsplit("/", 1)[0]
+
+        mgr = ocp.CheckpointManager(
+            base_path,
+            item_handlers={
+                "params": ocp.StandardCheckpointHandler(),
+                "opt_state": ocp.StandardCheckpointHandler(),
+                "config": ocp.JsonCheckpointHandler(),
+            },
+            options=ocp.CheckpointManagerOptions(max_to_keep=1),
+        )
+
+        try:
+            restored = mgr.restore(
+                step, args=ocp.args.Composite(config=ocp.args.JsonRestore(), params=ocp.args.StandardRestore())
+            )
+            config = restored["config"]
+            self._params = restored["params"]
+            self._fsq_tokenizer = fsq_tokenizer.FsqAttentionTokenizer(**config)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to load FSQ tokenizer checkpoint from {fsq_tokenizer_path}. Error: {e!s}"
+            ) from e
+
+        # Compile tokenize and detokenize functions
+        self._tokenize_fn = jax.jit(
+            lambda params, x: self._fsq_tokenizer.apply({"params": params}, x, method=self._fsq_tokenizer.tokenize)
+        )
+        self._detokenize_fn = jax.jit(
+            lambda params, x: self._fsq_tokenizer.apply({"params": params}, x, method=self._fsq_tokenizer.detokenize)
+        )
+
+        # Download base PaliGemma tokenizer
+        path = download.maybe_download("gs://big_vision/paligemma_tokenizer.model", gs={"token": "anon"})
+        with path.open("rb") as f:
+            self._paligemma_tokenizer = sentencepiece.SentencePieceProcessor(model_proto=f.read())
+
+        self._fast_skip_tokens = 128  # Skip last 128 tokens in PaliGemma vocab since they are special tokens
+
+    def tokenize(
+        self, prompt: str, state: np.ndarray, actions: np.ndarray | None
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        cleaned_text = prompt.lower().strip().replace("_", " ")
+
+        # Convention: state gets discretized into 256 discrete bins (assumed range after normalization: [-1, 1])
+        discretized_state = np.digitize(state, bins=np.linspace(-1, 1, 256 + 1)[:-1]) - 1
+
+        # Convention: prefix includes prompt and string-representation of state, followed by ';'
+        state_str = " ".join(map(str, discretized_state))
+        prefix = f"Task: {cleaned_text}, State: {state_str};\n"
+        prefix_tokens = self._paligemma_tokenizer.encode(prefix, add_bos=True)
+
+        if actions is not None:
+            raise NotImplementedError("FSQTokenizer does not support encoding actions atm (only for inference use)")
+        postfix_tokens = []
+
+        # Create output token sequence & masks
+        # AR mask is 0 on prefix (bidirectional attention) and 1 on postfix (causal attention to all previous tokens)
+        tokens = prefix_tokens + postfix_tokens
+        token_mask = [True] * len(tokens)
+        ar_mask = [0] * len(prefix_tokens) + [1] * len(postfix_tokens)
+        loss_mask = [False] * len(prefix_tokens) + [True] * len(postfix_tokens)  # Loss on postfix only
+
+        # Pad tokens to max length
+        tokens_len = len(tokens)
+        if tokens_len < self._max_len:
+            padding = [False] * (self._max_len - tokens_len)
+            tokens = tokens + padding
+            token_mask = token_mask + padding
+            ar_mask = ar_mask + padding
+            loss_mask = loss_mask + padding
+        else:
+            if len(tokens) > self._max_len:
+                logging.warning(
+                    f"Token length ({len(tokens)}) exceeds max length ({self._max_len}), truncating. "
+                    "Consider increasing the `max_token_len` in your model config if this happens frequently."
+                )
+            tokens = tokens[: self._max_len]
+            token_mask = token_mask[: self._max_len]
+            ar_mask = ar_mask[: self._max_len]
+            loss_mask = loss_mask[: self._max_len]
+
+        return np.asarray(tokens), np.asarray(token_mask), np.asarray(ar_mask), np.asarray(loss_mask)
+
+    def extract_actions(self, tokens: np.ndarray, action_horizon: int, action_dim: int) -> np.ndarray:
+        # Decode predicted output tokens
+        decoded_tokens = self._paligemma_tokenizer.decode(tokens.tolist())
+
+        # Extract actions from FAST model outputs
+        if "Action: " not in decoded_tokens:
+            return np.zeros((action_horizon, action_dim), dtype=np.float32)
+
+        # Extract actions from decoded tokens
+        raw_action_tokens = np.array(
+            self._paligemma_tokenizer.encode(decoded_tokens.split("Action: ")[1].split("|")[0].strip())
+        )
+        action_tokens = self._act_tokens_to_paligemma_tokens(raw_action_tokens)
+        try:
+            # Move computation to CPU and compile on-demand
+            device = jax.devices("cpu")[0]
+            with jax.default_device(device):
+                detok_act = self._detokenize_fn(self._params, action_tokens[None, ...])[0]
+            return detok_act[: action_horizon * action_dim].reshape([action_horizon, action_dim])
+        except Exception as e:
+            logging.warning(f"Error decoding FSQ: {e}")
+            return np.zeros((action_horizon, action_dim))
+
+    def _act_tokens_to_paligemma_tokens(self, tokens: np.ndarray | list[int]) -> np.ndarray:
+        if isinstance(tokens, list):
+            tokens = np.array(tokens)
+        return self._paligemma_tokenizer.vocab_size() - 1 - self._fast_skip_tokens - tokens

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/tokenizer_test.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+from openpi.models import tokenizer as _tokenizer
+
+
+def test_tokenize():
+    tokenizer = _tokenizer.PaligemmaTokenizer(max_len=10)
+    tokens, masks = tokenizer.tokenize("Hello, world!")
+
+    assert tokens.shape == (10,)
+    assert masks.shape == (10,)
+
+
+def test_fast_tokenizer():
+    prompt = "Hello, world!"
+    state = np.random.rand(5).astype(np.float32)
+    action = np.random.rand(3, 2).astype(np.float32)
+    tokenizer = _tokenizer.FASTTokenizer(max_len=256)
+    tokens, token_masks, ar_masks, loss_masks = tokenizer.tokenize(prompt, state, action)
+
+    assert tokens.shape == (256,)
+    assert token_masks.shape == (256,)
+    assert ar_masks.shape == (256,)
+    assert loss_masks.shape == (256,)
+
+    act = tokenizer.extract_actions(tokens, 3, 2)
+    assert act.shape == (3, 2)

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models/vit.py

@@ -0,0 +1,307 @@
+# Copyright 2024 Google LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""ViT implementation adapted from https://github.com/google-research/vision_transformer/blob/main/vit_jax/models_vit.py."""
+
+from collections.abc import Callable
+from typing import Any
+
+import flax.linen as nn
+import jax
+import jax.numpy as jnp
+
+from openpi.models import resnet as models_resnet
+
+Array = Any
+PRNGKey = Any
+Shape = tuple[int]
+Dtype = Any
+
+
+class IdentityLayer(nn.Module):
+    """Identity layer, convenient for giving a name to an array."""
+
+    @nn.compact
+    def __call__(self, x):
+        return x
+
+
+class AddPositionEmbs(nn.Module):
+    """Adds learned positional embeddings to the inputs.
+
+    Attributes:
+      posemb_init: positional embedding initializer.
+    """
+
+    posemb_init: Callable[[PRNGKey, Shape, Dtype], Array]
+    param_dtype: Dtype = jnp.float32
+
+    @nn.compact
+    def __call__(self, inputs):
+        """Applies the AddPositionEmbs module.
+
+        Args:
+          inputs: Inputs to the layer.
+
+        Returns:
+          Output tensor with shape `(bs, timesteps, in_dim)`.
+        """
+        # inputs.shape is (batch_size, seq_len, emb_dim).
+        assert inputs.ndim == 3, f"Number of dimensions should be 3, but it is: {inputs.ndim}"
+        pos_emb_shape = (1, inputs.shape[1], inputs.shape[2])
+        pe = self.param("pos_embedding", self.posemb_init, pos_emb_shape, self.param_dtype)
+        return inputs + pe
+
+
+class MlpBlock(nn.Module):
+    """Transformer MLP / feed-forward block."""
+
+    mlp_dim: int
+    dtype: Dtype = jnp.float32
+    param_dtype: Dtype = jnp.float32
+    out_dim: int | None = None
+    dropout_rate: float = 0.1
+    kernel_init: Callable[[PRNGKey, Shape, Dtype], Array] = nn.initializers.xavier_uniform()
+    bias_init: Callable[[PRNGKey, Shape, Dtype], Array] = nn.initializers.normal(stddev=1e-6)
+
+    @nn.compact
+    def __call__(self, inputs, *, deterministic):
+        """Applies Transformer MlpBlock module."""
+        actual_out_dim = inputs.shape[-1] if self.out_dim is None else self.out_dim
+        x = nn.Dense(
+            features=self.mlp_dim,
+            dtype=self.dtype,
+            param_dtype=self.param_dtype,
+            kernel_init=self.kernel_init,
+            bias_init=self.bias_init,
+        )(  # pytype: disable=wrong-arg-types
+            inputs
+        )
+        x = nn.gelu(x)
+        x = nn.Dropout(rate=self.dropout_rate)(x, deterministic=deterministic)
+        output = nn.Dense(
+            features=actual_out_dim,
+            dtype=self.dtype,
+            param_dtype=self.param_dtype,
+            kernel_init=self.kernel_init,
+            bias_init=self.bias_init,
+        )(  # pytype: disable=wrong-arg-types
+            x
+        )
+        return nn.Dropout(rate=self.dropout_rate)(output, deterministic=deterministic)
+
+
+class Encoder1DBlock(nn.Module):
+    """Transformer encoder layer.
+
+    Attributes:
+      inputs: input data.
+      mlp_dim: dimension of the mlp on top of attention block.
+      dtype: the dtype of the computation (default: float32).
+      dropout_rate: dropout rate.
+      attention_dropout_rate: dropout for attention heads.
+      deterministic: bool, deterministic or not (to apply dropout).
+      num_heads: Number of heads in nn.MultiHeadDotProductAttention
+    """
+
+    mlp_dim: int
+    num_heads: int
+    dtype: Dtype = jnp.float32
+    dropout_rate: float = 0.1
+    attention_dropout_rate: float = 0.1
+
+    @nn.compact
+    def __call__(self, inputs, deterministic):
+        """Applies Encoder1DBlock module.
+
+        Args:
+          inputs: Inputs to the layer.
+          deterministic: Dropout will not be applied when set to true.
+
+        Returns:
+          output after transformer encoder block.
+        """
+
+        # Attention block.
+        assert inputs.ndim == 3, f"Expected (batch, seq, hidden) got {inputs.shape}"
+        x = nn.LayerNorm(dtype=self.dtype)(inputs)
+        x = nn.MultiHeadDotProductAttention(
+            dtype=self.dtype,
+            kernel_init=nn.initializers.xavier_uniform(),
+            broadcast_dropout=False,
+            deterministic=deterministic,
+            dropout_rate=self.attention_dropout_rate,
+            num_heads=self.num_heads,
+            # why isn't this true by default???
+            force_fp32_for_softmax=True,
+        )(x, x)
+        x = nn.Dropout(rate=self.dropout_rate)(x, deterministic=deterministic)
+        x = x + inputs
+
+        # MLP block.
+        y = nn.LayerNorm(dtype=self.dtype)(x)
+        y = MlpBlock(mlp_dim=self.mlp_dim, dtype=self.dtype, dropout_rate=self.dropout_rate)(
+            y, deterministic=deterministic
+        )
+
+        return x + y, None
+
+
+class Encoder(nn.Module):
+    """Transformer Model Encoder for sequence to sequence translation.
+
+    Attributes:
+      num_layers: number of layers
+      mlp_dim: dimension of the mlp on top of attention block
+      num_heads: Number of heads in nn.MultiHeadDotProductAttention
+      dropout_rate: dropout rate.
+      attention_dropout_rate: dropout rate in self attention.
+    """
+
+    dtype: jax.typing.DTypeLike
+    num_layers: int
+    mlp_dim: int
+    num_heads: int
+    dropout_rate: float = 0.1
+    attention_dropout_rate: float = 0.1
+    add_position_embedding: bool = True
+
+    @nn.compact
+    def __call__(self, x, *, train):
+        """Applies Transformer model on the inputs.
+
+        Args:
+          x: Inputs to the layer.
+          train: Set to `True` when training.
+
+        Returns:
+          output of a transformer encoder.
+        """
+        assert x.ndim == 3  # (batch, len, emb)
+
+        if self.add_position_embedding:
+            x = AddPositionEmbs(
+                posemb_init=nn.initializers.normal(stddev=0.02),  # from BERT.
+                name="posembed_input",
+            )(x)
+            x = nn.Dropout(rate=self.dropout_rate)(x, deterministic=not train)
+
+        x = x.astype(self.dtype)
+        # Input Encoder
+        block = nn.remat(Encoder1DBlock, prevent_cse=False, static_argnums=(2,))
+        x, _ = nn.scan(
+            block,
+            variable_axes={"params": 0},
+            split_rngs={"params": True, "dropout": True},
+            in_axes=nn.broadcast,
+            length=self.num_layers,
+        )(
+            name="encoderblock",
+            mlp_dim=self.mlp_dim,
+            dropout_rate=self.dropout_rate,
+            attention_dropout_rate=self.attention_dropout_rate,
+            dtype=self.dtype,
+            num_heads=self.num_heads,
+        )(x, not train)
+        return nn.LayerNorm(name="encoder_norm", dtype=self.dtype)(x)
+
+
+class VisionTransformer(nn.Module):
+    """VisionTransformer."""
+
+    dtype: jax.typing.DTypeLike
+    num_classes: int
+    patches: Any
+    transformer: Any
+    hidden_size: int
+    resnet: Any | None = None
+    representation_size: int | None = None
+    classifier: str = "token"
+    head_bias_init: float = 0.0
+    encoder: type[nn.Module] = Encoder
+    model_name: str | None = None
+
+    @nn.compact
+    def __call__(self, inputs, *, train):
+        x = inputs
+        # (Possibly partial) ResNet root.
+        if self.resnet is not None:
+            width = int(64 * self.resnet.width_factor)
+
+            # Root block.
+            x = models_resnet.StdConv(
+                features=width, kernel_size=(7, 7), strides=(2, 2), use_bias=False, name="conv_root"
+            )(x)
+            x = nn.GroupNorm(name="gn_root")(x)
+            x = nn.relu(x)
+            x = nn.max_pool(x, window_shape=(3, 3), strides=(2, 2), padding="SAME")
+
+            # ResNet stages.
+            if self.resnet.num_layers:
+                x = models_resnet.ResNetStage(
+                    block_size=self.resnet.num_layers[0], nout=width, first_stride=(1, 1), name="block1"
+                )(x)
+                for i, block_size in enumerate(self.resnet.num_layers[1:], 1):
+                    x = models_resnet.ResNetStage(
+                        block_size=block_size, nout=width * 2**i, first_stride=(2, 2), name=f"block{i + 1}"
+                    )(x)
+
+        n, h, w, c = x.shape
+
+        # We can merge s2d+emb into a single conv; it's the same.
+        x = nn.Conv(
+            features=self.hidden_size,
+            kernel_size=self.patches.size,
+            strides=self.patches.size,
+            padding="VALID",
+            name="embedding",
+        )(x)
+
+        # Here, x is a grid of embeddings.
+
+        # (Possibly partial) Transformer.
+        if self.transformer is not None:
+            n, h, w, c = x.shape
+            x = jnp.reshape(x, [n, h * w, c])
+
+            # If we want to add a class token, add it here.
+            if self.classifier in ["token", "token_unpooled"]:
+                cls = self.param("cls", nn.initializers.zeros, (1, 1, c))
+                cls = jnp.tile(cls, [n, 1, 1])
+                x = jnp.concatenate([cls, x], axis=1)
+
+            x = self.encoder(name="Transformer", **self.transformer, dtype=self.dtype)(x, train=train)
+
+        if self.classifier == "token":
+            x = x[:, 0]
+        elif self.classifier == "gap":
+            x = jnp.mean(x, axis=list(range(1, x.ndim - 1)))  # (1,) or (1,2)
+        elif self.classifier in ["unpooled", "token_unpooled"]:
+            pass
+        else:
+            raise ValueError(f"Invalid classifier={self.classifier}")
+
+        if self.representation_size is not None:
+            x = nn.Dense(features=self.representation_size, name="pre_logits")(x)
+            x = nn.tanh(x)
+        else:
+            x = IdentityLayer(name="pre_logits")(x)
+
+        if self.num_classes:
+            x = nn.Dense(
+                features=self.num_classes,
+                name="head",
+                kernel_init=nn.initializers.zeros,
+                bias_init=nn.initializers.constant(self.head_bias_init),
+            )(x)
+        return x

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/models_pytorch/preprocessing_pytorch.py

@@ -0,0 +1,173 @@
+from collections.abc import Sequence
+import logging
+
+import torch
+
+from openpi.shared import image_tools
+
+logger = logging.getLogger("openpi")
+
+# Constants moved from model.py
+IMAGE_KEYS = (
+    "base_0_rgb",
+    "left_wrist_0_rgb",
+    "right_wrist_0_rgb",
+)
+
+IMAGE_RESOLUTION = (224, 224)
+
+
+def preprocess_observation_pytorch(
+    observation,
+    *,
+    train: bool = False,
+    image_keys: Sequence[str] = IMAGE_KEYS,
+    image_resolution: tuple[int, int] = IMAGE_RESOLUTION,
+):
+    """Torch.compile-compatible version of preprocess_observation_pytorch with simplified type annotations.
+
+    This function avoids complex type annotations that can cause torch.compile issues.
+    """
+    if not set(image_keys).issubset(observation.images):
+        raise ValueError(f"images dict missing keys: expected {image_keys}, got {list(observation.images)}")
+
+    batch_shape = observation.state.shape[:-1]
+
+    out_images = {}
+    for key in image_keys:
+        image = observation.images[key]
+
+        # TODO: This is a hack to handle both [B, C, H, W] and [B, H, W, C] formats
+        # Handle both [B, C, H, W] and [B, H, W, C] formats
+        is_channels_first = image.shape[1] == 3  # Check if channels are in dimension 1
+
+        if is_channels_first:
+            # Convert [B, C, H, W] to [B, H, W, C] for processing
+            image = image.permute(0, 2, 3, 1)
+
+        if image.shape[1:3] != image_resolution:
+            logger.info(f"Resizing image {key} from {image.shape[1:3]} to {image_resolution}")
+            image = image_tools.resize_with_pad_torch(image, *image_resolution)
+
+        if train:
+            # Convert from [-1, 1] to [0, 1] for PyTorch augmentations
+            image = image / 2.0 + 0.5
+
+            # Apply PyTorch-based augmentations
+            if "wrist" not in key:
+                # Geometric augmentations for non-wrist cameras
+                height, width = image.shape[1:3]
+
+                # Random crop and resize
+                crop_height = int(height * 0.95)
+                crop_width = int(width * 0.95)
+
+                # Random crop
+                max_h = height - crop_height
+                max_w = width - crop_width
+                if max_h > 0 and max_w > 0:
+                    # Use tensor operations instead of .item() for torch.compile compatibility
+                    start_h = torch.randint(0, max_h + 1, (1,), device=image.device)
+                    start_w = torch.randint(0, max_w + 1, (1,), device=image.device)
+                    image = image[:, start_h : start_h + crop_height, start_w : start_w + crop_width, :]
+
+                # Resize back to original size
+                image = torch.nn.functional.interpolate(
+                    image.permute(0, 3, 1, 2),  # [b, h, w, c] -> [b, c, h, w]
+                    size=(height, width),
+                    mode="bilinear",
+                    align_corners=False,
+                ).permute(0, 2, 3, 1)  # [b, c, h, w] -> [b, h, w, c]
+
+                # Random rotation (small angles)
+                # Use tensor operations instead of .item() for torch.compile compatibility
+                angle = torch.rand(1, device=image.device) * 10 - 5  # Random angle between -5 and 5 degrees
+                if torch.abs(angle) > 0.1:  # Only rotate if angle is significant
+                    # Convert to radians
+                    angle_rad = angle * torch.pi / 180.0
+
+                    # Create rotation matrix
+                    cos_a = torch.cos(angle_rad)
+                    sin_a = torch.sin(angle_rad)
+
+                    # Apply rotation using grid_sample
+                    grid_x = torch.linspace(-1, 1, width, device=image.device)
+                    grid_y = torch.linspace(-1, 1, height, device=image.device)
+
+                    # Create meshgrid
+                    grid_y, grid_x = torch.meshgrid(grid_y, grid_x, indexing="ij")
+
+                    # Expand to batch dimension
+                    grid_x = grid_x.unsqueeze(0).expand(image.shape[0], -1, -1)
+                    grid_y = grid_y.unsqueeze(0).expand(image.shape[0], -1, -1)
+
+                    # Apply rotation transformation
+                    grid_x_rot = grid_x * cos_a - grid_y * sin_a
+                    grid_y_rot = grid_x * sin_a + grid_y * cos_a
+
+                    # Stack and reshape for grid_sample
+                    grid = torch.stack([grid_x_rot, grid_y_rot], dim=-1)
+
+                    image = torch.nn.functional.grid_sample(
+                        image.permute(0, 3, 1, 2),  # [b, h, w, c] -> [b, c, h, w]
+                        grid,
+                        mode="bilinear",
+                        padding_mode="zeros",
+                        align_corners=False,
+                    ).permute(0, 2, 3, 1)  # [b, c, h, w] -> [b, h, w, c]
+
+            # Color augmentations for all cameras
+            # Random brightness
+            # Use tensor operations instead of .item() for torch.compile compatibility
+            brightness_factor = 0.7 + torch.rand(1, device=image.device) * 0.6  # Random factor between 0.7 and 1.3
+            image = image * brightness_factor
+
+            # Random contrast
+            # Use tensor operations instead of .item() for torch.compile compatibility
+            contrast_factor = 0.6 + torch.rand(1, device=image.device) * 0.8  # Random factor between 0.6 and 1.4
+            mean = image.mean(dim=[1, 2, 3], keepdim=True)
+            image = (image - mean) * contrast_factor + mean
+
+            # Random saturation (convert to HSV, modify S, convert back)
+            # For simplicity, we'll just apply a random scaling to the color channels
+            # Use tensor operations instead of .item() for torch.compile compatibility
+            saturation_factor = 0.5 + torch.rand(1, device=image.device) * 1.0  # Random factor between 0.5 and 1.5
+            gray = image.mean(dim=-1, keepdim=True)
+            image = gray + (image - gray) * saturation_factor
+
+            # Clamp values to [0, 1]
+            image = torch.clamp(image, 0, 1)
+
+            # Back to [-1, 1]
+            image = image * 2.0 - 1.0
+
+        # Convert back to [B, C, H, W] format if it was originally channels-first
+        if is_channels_first:
+            image = image.permute(0, 3, 1, 2)  # [B, H, W, C] -> [B, C, H, W]
+
+        out_images[key] = image
+
+    # obtain mask
+    out_masks = {}
+    for key in out_images:
+        if key not in observation.image_masks:
+            # do not mask by default
+            out_masks[key] = torch.ones(batch_shape, dtype=torch.bool, device=observation.state.device)
+        else:
+            out_masks[key] = observation.image_masks[key]
+
+    # Create a simple object with the required attributes instead of using the complex Observation class
+    class SimpleProcessedObservation:
+        def __init__(self, **kwargs):
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+
+    return SimpleProcessedObservation(
+        images=out_images,
+        image_masks=out_masks,
+        state=observation.state,
+        tokenized_prompt=observation.tokenized_prompt,
+        tokenized_prompt_mask=observation.tokenized_prompt_mask,
+        token_ar_mask=observation.token_ar_mask,
+        token_loss_mask=observation.token_loss_mask,
+    )

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/serving/websocket_policy_server.py

@@ -0,0 +1,90 @@
+import asyncio
+import http
+import logging
+import time
+import traceback
+
+from openpi_client import base_policy as _base_policy
+from openpi_client import msgpack_numpy
+import websockets.asyncio.server as _server
+import websockets.frames
+
+logger = logging.getLogger(__name__)
+
+
+class WebsocketPolicyServer:
+    """Serves a policy using the websocket protocol. See websocket_client_policy.py for a client implementation.
+
+    Currently only implements the `load` and `infer` methods.
+    """
+
+    def __init__(
+        self,
+        policy: _base_policy.BasePolicy,
+        host: str = "0.0.0.0",
+        port: int | None = None,
+        metadata: dict | None = None,
+    ) -> None:
+        self._policy = policy
+        self._host = host
+        self._port = port
+        self._metadata = metadata or {}
+        logging.getLogger("websockets.server").setLevel(logging.INFO)
+
+    def serve_forever(self) -> None:
+        asyncio.run(self.run())
+
+    async def run(self):
+        async with _server.serve(
+            self._handler,
+            self._host,
+            self._port,
+            compression=None,
+            max_size=None,
+            process_request=_health_check,
+        ) as server:
+            await server.serve_forever()
+
+    async def _handler(self, websocket: _server.ServerConnection):
+        logger.info(f"Connection from {websocket.remote_address} opened")
+        packer = msgpack_numpy.Packer()
+
+        await websocket.send(packer.pack(self._metadata))
+
+        prev_total_time = None
+        while True:
+            try:
+                start_time = time.monotonic()
+                obs = msgpack_numpy.unpackb(await websocket.recv())
+
+                infer_time = time.monotonic()
+                action = self._policy.infer(obs)
+                infer_time = time.monotonic() - infer_time
+
+                action["server_timing"] = {
+                    "infer_ms": infer_time * 1000,
+                }
+                if prev_total_time is not None:
+                    # We can only record the last total time since we also want to include the send time.
+                    action["server_timing"]["prev_total_ms"] = prev_total_time * 1000
+
+                await websocket.send(packer.pack(action))
+                prev_total_time = time.monotonic() - start_time
+
+            except websockets.ConnectionClosed:
+                logger.info(f"Connection from {websocket.remote_address} closed")
+                break
+            except Exception:
+                await websocket.send(traceback.format_exc())
+                await websocket.close(
+                    code=websockets.frames.CloseCode.INTERNAL_ERROR,
+                    reason="Internal server error. Traceback included in previous frame.",
+                )
+                raise
+
+
+def _health_check(connection: _server.ServerConnection, request: _server.Request) -> _server.Response | None:
+    if request.path == "/healthz":
+        return connection.respond(http.HTTPStatus.OK, "OK\n")
+    # Continue with the normal request handling.
+    return None

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/array_typing.py

@@ -0,0 +1,89 @@
+import contextlib
+import functools as ft
+import inspect
+from typing import TypeAlias, TypeVar, cast
+
+import beartype
+import jax
+import jax._src.tree_util as private_tree_util
+import jax.core
+from jaxtyping import ArrayLike
+from jaxtyping import Bool  # noqa: F401
+from jaxtyping import DTypeLike  # noqa: F401
+from jaxtyping import Float
+from jaxtyping import Int  # noqa: F401
+from jaxtyping import Key  # noqa: F401
+from jaxtyping import Num  # noqa: F401
+from jaxtyping import PyTree
+from jaxtyping import Real  # noqa: F401
+from jaxtyping import UInt8  # noqa: F401
+from jaxtyping import config
+from jaxtyping import jaxtyped
+import jaxtyping._decorator
+import torch
+
+# patch jaxtyping to handle https://github.com/patrick-kidger/jaxtyping/issues/277.
+# the problem is that custom PyTree nodes are sometimes initialized with arbitrary types (e.g., `jax.ShapeDtypeStruct`,
+# `jax.Sharding`, or even <object>) due to JAX tracing operations. this patch skips typechecking when the stack trace
+# contains `jax._src.tree_util`, which should only be the case during tree unflattening.
+_original_check_dataclass_annotations = jaxtyping._decorator._check_dataclass_annotations  # noqa: SLF001
+# Redefine Array to include both JAX arrays and PyTorch tensors
+Array = jax.Array | torch.Tensor
+
+
+def _check_dataclass_annotations(self, typechecker):
+    if not any(
+        frame.frame.f_globals.get("__name__") in {"jax._src.tree_util", "flax.nnx.transforms.compilation"}
+        for frame in inspect.stack()
+    ):
+        return _original_check_dataclass_annotations(self, typechecker)
+    return None
+
+
+jaxtyping._decorator._check_dataclass_annotations = _check_dataclass_annotations  # noqa: SLF001
+
+KeyArrayLike: TypeAlias = jax.typing.ArrayLike
+Params: TypeAlias = PyTree[Float[ArrayLike, "..."]]
+
+T = TypeVar("T")
+
+
+# runtime type-checking decorator
+def typecheck(t: T) -> T:
+    return cast(T, ft.partial(jaxtyped, typechecker=beartype.beartype)(t))
+
+
+@contextlib.contextmanager
+def disable_typechecking():
+    initial = config.jaxtyping_disable
+    config.update("jaxtyping_disable", True)  # noqa: FBT003
+    yield
+    config.update("jaxtyping_disable", initial)
+
+
+def check_pytree_equality(*, expected: PyTree, got: PyTree, check_shapes: bool = False, check_dtypes: bool = False):
+    """Checks that two PyTrees have the same structure and optionally checks shapes and dtypes. Creates a much nicer
+    error message than if `jax.tree.map` is naively used on PyTrees with different structures.
+    """
+
+    if errors := list(private_tree_util.equality_errors(expected, got)):
+        raise ValueError(
+            "PyTrees have different structure:\n"
+            + (
+                "\n".join(
+                    f"   - at keypath '{jax.tree_util.keystr(path)}': expected {thing1}, got {thing2}, so {explanation}.\n"
+                    for path, thing1, thing2, explanation in errors
+                )
+            )
+        )
+
+    if check_shapes or check_dtypes:
+
+        def check(kp, x, y):
+            if check_shapes and x.shape != y.shape:
+                raise ValueError(f"Shape mismatch at {jax.tree_util.keystr(kp)}: expected {x.shape}, got {y.shape}")
+
+            if check_dtypes and x.dtype != y.dtype:
+                raise ValueError(f"Dtype mismatch at {jax.tree_util.keystr(kp)}: expected {x.dtype}, got {y.dtype}")
+
+        jax.tree_util.tree_map_with_path(check, expected, got)

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/download.py

@@ -0,0 +1,226 @@
+import concurrent.futures
+import datetime
+import logging
+import os
+import pathlib
+import re
+import shutil
+import stat
+import subprocess
+import time
+import urllib.parse
+
+import filelock
+import fsspec
+import fsspec.generic
+import tqdm_loggable.auto as tqdm
+
+# Environment variable to control cache directory path, ~/.cache/openpi will be used by default.
+_OPENPI_DATA_HOME = "OPENPI_DATA_HOME"
+DEFAULT_CACHE_DIR = "~/.cache/openpi"
+
+logger = logging.getLogger(__name__)
+
+
+def get_cache_dir() -> pathlib.Path:
+    cache_dir = pathlib.Path(os.getenv(_OPENPI_DATA_HOME, DEFAULT_CACHE_DIR)).expanduser().resolve()
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    _set_folder_permission(cache_dir)
+    return cache_dir
+
+
+def maybe_download(url: str, *, force_download: bool = False, **kwargs) -> pathlib.Path:
+    """Download a file or directory from a remote filesystem to the local cache, and return the local path.
+
+    If the local file already exists, it will be returned directly.
+
+    It is safe to call this function concurrently from multiple processes.
+    See `get_cache_dir` for more details on the cache directory.
+
+    Args:
+        url: URL to the file to download.
+        force_download: If True, the file will be downloaded even if it already exists in the cache.
+        **kwargs: Additional arguments to pass to fsspec.
+
+    Returns:
+        Local path to the downloaded file or directory. That path is guaranteed to exist and is absolute.
+    """
+    # Don't use fsspec to parse the url to avoid unnecessary connection to the remote filesystem.
+    parsed = urllib.parse.urlparse(url)
+
+    # Short circuit if this is a local path.
+    if parsed.scheme == "":
+        path = pathlib.Path(url)
+        if not path.exists():
+            raise FileNotFoundError(f"File not found at {url}")
+        return path.resolve()
+
+    cache_dir = get_cache_dir()
+
+    local_path = cache_dir / parsed.netloc / parsed.path.strip("/")
+    local_path = local_path.resolve()
+
+    # Check if the cache should be invalidated.
+    invalidate_cache = False
+    if local_path.exists():
+        if force_download or _should_invalidate_cache(cache_dir, local_path):
+            invalidate_cache = True
+        else:
+            return local_path
+
+    try:
+        lock_path = local_path.with_suffix(".lock")
+        with filelock.FileLock(lock_path):
+            # Ensure consistent permissions for the lock file.
+            _ensure_permissions(lock_path)
+            # First, remove the existing cache if it is expired.
+            if invalidate_cache:
+                logger.info(f"Removing expired cached entry: {local_path}")
+                if local_path.is_dir():
+                    shutil.rmtree(local_path)
+                else:
+                    local_path.unlink()
+
+            if not local_path.exists():
+                # Download the data to a local cache.
+                logger.info(f"Downloading {url} to {local_path}")
+                scratch_path = local_path.with_suffix(".partial")
+                # A previously interrupted transfer can leave this scratch path
+                # behind. fsspec then nests a fresh recursive download inside
+                # it, while stale truncated shards remain at its root. Start a
+                # new download from an empty scratch path instead.
+                if scratch_path.exists():
+                    logger.warning(f"Removing stale partial download: {scratch_path}")
+                    if scratch_path.is_dir():
+                        shutil.rmtree(scratch_path)
+                    else:
+                        scratch_path.unlink()
+                # Route openpi-assets through gsutil to avoid gcsfs auth issues with this bucket.
+                # All other gs:// URLs (e.g. big_vision) continue to use gcsfs as normal.
+                if parsed.scheme == "gs" and parsed.netloc == "openpi-assets":
+                    _download_gsutil(url, scratch_path, **kwargs)
+                else:
+                    _download_fsspec(url, scratch_path, **kwargs)
+
+                shutil.move(scratch_path, local_path)
+                _ensure_permissions(local_path)
+
+    except PermissionError as e:
+        msg = (
+            f"Local file permission error was encountered while downloading {url}. "
+            f"Please try again after removing the cached data using: `rm -rf {local_path}*`"
+        )
+        raise PermissionError(msg) from e
+
+    return local_path
+
+
+def _download_gsutil(url: str, local_path: pathlib.Path, **kwargs) -> None:
+    """Download a file or directory from GCS using gsutil if available, otherwise fall back to gcsfs."""
+    if shutil.which("gsutil") is None:
+        logger.warning(
+            "gsutil not found, falling back to gcsfs. This may fail if GCP credentials are not configured correctly."
+        )
+        _download_fsspec(url, local_path, **kwargs)
+        return
+    local_path.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        ["gsutil", "-m", "cp", "-r", f"{url}/*", str(local_path)],
+        check=True,
+    )
+
+
+def _download_fsspec(url: str, local_path: pathlib.Path, **kwargs) -> None:
+    """Download a file from a remote filesystem to the local cache, and return the local path."""
+    fs, _ = fsspec.core.url_to_fs(url, **kwargs)
+    info = fs.info(url)
+    # Folders are represented by 0-byte objects with a trailing forward slash.
+    if is_dir := (info["type"] == "directory" or (info["size"] == 0 and info["name"].endswith("/"))):
+        total_size = fs.du(url)
+    else:
+        total_size = info["size"]
+    with tqdm.tqdm(total=total_size, unit="iB", unit_scale=True, unit_divisor=1024) as pbar:
+        executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
+        future = executor.submit(fs.get, url, local_path, recursive=is_dir)
+        while not future.done():
+            current_size = sum(f.stat().st_size for f in [*local_path.rglob("*"), local_path] if f.is_file())
+            pbar.update(current_size - pbar.n)
+            time.sleep(1)
+        pbar.update(total_size - pbar.n)
+
+
+def _set_permission(path: pathlib.Path, target_permission: int):
+    """chmod requires executable permission to be set, so we skip if the permission is already match with the target."""
+    if path.stat().st_mode & target_permission == target_permission:
+        logger.debug(f"Skipping {path} because it already has correct permissions")
+        return
+    path.chmod(target_permission)
+    logger.debug(f"Set {path} to {target_permission}")
+
+
+def _set_folder_permission(folder_path: pathlib.Path) -> None:
+    """Set folder permission to be read, write and searchable."""
+    _set_permission(folder_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+
+
+def _ensure_permissions(path: pathlib.Path) -> None:
+    """Since we are sharing cache directory with containerized runtime as well as training script, we need to
+    ensure that the cache directory has the correct permissions.
+    """
+
+    def _setup_folder_permission_between_cache_dir_and_path(path: pathlib.Path) -> None:
+        cache_dir = get_cache_dir()
+        relative_path = path.relative_to(cache_dir)
+        moving_path = cache_dir
+        for part in relative_path.parts:
+            _set_folder_permission(moving_path / part)
+            moving_path = moving_path / part
+
+    def _set_file_permission(file_path: pathlib.Path) -> None:
+        """Set all files to be read & writable, if it is a script, keep it as a script."""
+        file_rw = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IROTH | stat.S_IWOTH
+        if file_path.stat().st_mode & 0o100:
+            _set_permission(file_path, file_rw | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        else:
+            _set_permission(file_path, file_rw)
+
+    _setup_folder_permission_between_cache_dir_and_path(path)
+    for root, dirs, files in os.walk(str(path)):
+        root_path = pathlib.Path(root)
+        for file in files:
+            file_path = root_path / file
+            _set_file_permission(file_path)
+
+        for dir in dirs:
+            dir_path = root_path / dir
+            _set_folder_permission(dir_path)
+
+
+def _get_mtime(year: int, month: int, day: int) -> float:
+    """Get the mtime of a given date at midnight UTC."""
+    date = datetime.datetime(year, month, day, tzinfo=datetime.UTC)
+    return time.mktime(date.timetuple())
+
+
+# Map of relative paths, defined as regular expressions, to expiration timestamps (mtime format).
+# Partial matching will be used from top to bottom and the first match will be chosen.
+# Cached entries will be retained only if they are newer than the expiration timestamp.
+_INVALIDATE_CACHE_DIRS: dict[re.Pattern, float] = {
+    re.compile("openpi-assets/checkpoints/pi0_aloha_pen_uncap"): _get_mtime(2025, 2, 17),
+    re.compile("openpi-assets/checkpoints/pi0_libero"): _get_mtime(2025, 2, 6),
+    re.compile("openpi-assets/checkpoints/"): _get_mtime(2025, 2, 3),
+}
+
+
+def _should_invalidate_cache(cache_dir: pathlib.Path, local_path: pathlib.Path) -> bool:
+    """Invalidate the cache if it is expired. Return True if the cache was invalidated."""
+
+    assert local_path.exists(), f"File not found at {local_path}"
+
+    relative_path = str(local_path.relative_to(cache_dir))
+    for pattern, expire_time in _INVALIDATE_CACHE_DIRS.items():
+        if pattern.match(relative_path):
+            # Remove if not newer than the expiration timestamp.
+            return local_path.stat().st_mtime <= expire_time
+
+    return False

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/download_test.py

@@ -0,0 +1,54 @@
+import pathlib
+
+import pytest
+
+import openpi.shared.download as download
+
+
+@pytest.fixture(scope="session", autouse=True)
+def set_openpi_data_home(tmp_path_factory):
+    temp_dir = tmp_path_factory.mktemp("openpi_data")
+    with pytest.MonkeyPatch().context() as mp:
+        mp.setenv("OPENPI_DATA_HOME", str(temp_dir))
+        yield
+
+
+def test_download_local(tmp_path: pathlib.Path):
+    local_path = tmp_path / "local"
+    local_path.touch()
+
+    result = download.maybe_download(str(local_path))
+    assert result == local_path
+
+    with pytest.raises(FileNotFoundError):
+        download.maybe_download("bogus")
+
+
+def test_download_gs_dir():
+    remote_path = "gs://openpi-assets/testdata/random"
+
+    local_path = download.maybe_download(remote_path)
+    assert local_path.exists()
+
+    new_local_path = download.maybe_download(remote_path)
+    assert new_local_path == local_path
+
+
+def test_download_gs():
+    remote_path = "gs://openpi-assets/testdata/random/random_512kb.bin"
+
+    local_path = download.maybe_download(remote_path)
+    assert local_path.exists()
+
+    new_local_path = download.maybe_download(remote_path)
+    assert new_local_path == local_path
+
+
+def test_download_fsspec():
+    remote_path = "gs://big_vision/paligemma_tokenizer.model"
+
+    local_path = download.maybe_download(remote_path, gs={"token": "anon"})
+    assert local_path.exists()
+
+    new_local_path = download.maybe_download(remote_path, gs={"token": "anon"})
+    assert new_local_path == local_path

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/image_tools.py

@@ -0,0 +1,126 @@
+import functools
+
+import jax
+import jax.numpy as jnp
+import torch
+import torch.nn.functional as F  # noqa: N812
+
+import openpi.shared.array_typing as at
+
+
+@functools.partial(jax.jit, static_argnums=(1, 2, 3))
+@at.typecheck
+def resize_with_pad(
+    images: at.UInt8[at.Array, "*b h w c"] | at.Float[at.Array, "*b h w c"],
+    height: int,
+    width: int,
+    method: jax.image.ResizeMethod = jax.image.ResizeMethod.LINEAR,
+) -> at.UInt8[at.Array, "*b {height} {width} c"] | at.Float[at.Array, "*b {height} {width} c"]:
+    """Replicates tf.image.resize_with_pad. Resizes an image to a target height and width without distortion
+    by padding with black. If the image is float32, it must be in the range [-1, 1].
+    """
+    has_batch_dim = images.ndim == 4
+    if not has_batch_dim:
+        images = images[None]  # type: ignore
+    cur_height, cur_width = images.shape[1:3]
+    ratio = max(cur_width / width, cur_height / height)
+    resized_height = int(cur_height / ratio)
+    resized_width = int(cur_width / ratio)
+    resized_images = jax.image.resize(
+        images, (images.shape[0], resized_height, resized_width, images.shape[3]), method=method
+    )
+    if images.dtype == jnp.uint8:
+        # round from float back to uint8
+        resized_images = jnp.round(resized_images).clip(0, 255).astype(jnp.uint8)
+    elif images.dtype == jnp.float32:
+        resized_images = resized_images.clip(-1.0, 1.0)
+    else:
+        raise ValueError(f"Unsupported image dtype: {images.dtype}")
+
+    pad_h0, remainder_h = divmod(height - resized_height, 2)
+    pad_h1 = pad_h0 + remainder_h
+    pad_w0, remainder_w = divmod(width - resized_width, 2)
+    pad_w1 = pad_w0 + remainder_w
+    padded_images = jnp.pad(
+        resized_images,
+        ((0, 0), (pad_h0, pad_h1), (pad_w0, pad_w1), (0, 0)),
+        constant_values=0 if images.dtype == jnp.uint8 else -1.0,
+    )
+
+    if not has_batch_dim:
+        padded_images = padded_images[0]
+    return padded_images
+
+
+def resize_with_pad_torch(
+    images: torch.Tensor,
+    height: int,
+    width: int,
+    mode: str = "bilinear",
+) -> torch.Tensor:
+    """PyTorch version of resize_with_pad. Resizes an image to a target height and width without distortion
+    by padding with black. If the image is float32, it must be in the range [-1, 1].
+
+    Args:
+        images: Tensor of shape [*b, h, w, c] or [*b, c, h, w]
+        height: Target height
+        width: Target width
+        mode: Interpolation mode ('bilinear', 'nearest', etc.)
+
+    Returns:
+        Resized and padded tensor with same shape format as input
+    """
+    # Check if input is in channels-last format [*b, h, w, c] or channels-first [*b, c, h, w]
+    if images.shape[-1] <= 4:  # Assume channels-last format
+        channels_last = True
+        # Convert to channels-first for torch operations
+        if images.dim() == 3:
+            images = images.unsqueeze(0)  # Add batch dimension
+        images = images.permute(0, 3, 1, 2)  # [b, h, w, c] -> [b, c, h, w]
+    else:
+        channels_last = False
+        if images.dim() == 3:
+            images = images.unsqueeze(0)  # Add batch dimension
+
+    batch_size, channels, cur_height, cur_width = images.shape
+
+    # Calculate resize ratio
+    ratio = max(cur_width / width, cur_height / height)
+    resized_height = int(cur_height / ratio)
+    resized_width = int(cur_width / ratio)
+
+    # Resize
+    resized_images = F.interpolate(
+        images, size=(resized_height, resized_width), mode=mode, align_corners=False if mode == "bilinear" else None
+    )
+
+    # Handle dtype-specific clipping
+    if images.dtype == torch.uint8:
+        resized_images = torch.round(resized_images).clamp(0, 255).to(torch.uint8)
+    elif images.dtype == torch.float32:
+        resized_images = resized_images.clamp(-1.0, 1.0)
+    else:
+        raise ValueError(f"Unsupported image dtype: {images.dtype}")
+
+    # Calculate padding
+    pad_h0, remainder_h = divmod(height - resized_height, 2)
+    pad_h1 = pad_h0 + remainder_h
+    pad_w0, remainder_w = divmod(width - resized_width, 2)
+    pad_w1 = pad_w0 + remainder_w
+
+    # Pad
+    constant_value = 0 if images.dtype == torch.uint8 else -1.0
+    padded_images = F.pad(
+        resized_images,
+        (pad_w0, pad_w1, pad_h0, pad_h1),  # left, right, top, bottom
+        mode="constant",
+        value=constant_value,
+    )
+
+    # Convert back to original format if needed
+    if channels_last:
+        padded_images = padded_images.permute(0, 2, 3, 1)  # [b, c, h, w] -> [b, h, w, c]
+        if batch_size == 1 and images.shape[0] == 1:
+            padded_images = padded_images.squeeze(0)  # Remove batch dimension if it was added
+
+    return padded_images

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/image_tools_test.py

@@ -0,0 +1,37 @@
+import jax.numpy as jnp
+
+from openpi.shared import image_tools
+
+
+def test_resize_with_pad_shapes():
+    # Test case 1: Resize image with larger dimensions
+    images = jnp.zeros((2, 10, 10, 3), dtype=jnp.uint8)  # Input images of shape (batch_size, height, width, channels)
+    height = 20
+    width = 20
+    resized_images = image_tools.resize_with_pad(images, height, width)
+    assert resized_images.shape == (2, height, width, 3)
+    assert jnp.all(resized_images == 0)
+
+    # Test case 2: Resize image with smaller dimensions
+    images = jnp.zeros((3, 30, 30, 3), dtype=jnp.uint8)
+    height = 15
+    width = 15
+    resized_images = image_tools.resize_with_pad(images, height, width)
+    assert resized_images.shape == (3, height, width, 3)
+    assert jnp.all(resized_images == 0)
+
+    # Test case 3: Resize image with the same dimensions
+    images = jnp.zeros((1, 50, 50, 3), dtype=jnp.uint8)
+    height = 50
+    width = 50
+    resized_images = image_tools.resize_with_pad(images, height, width)
+    assert resized_images.shape == (1, height, width, 3)
+    assert jnp.all(resized_images == 0)
+
+    # Test case 3: Resize image with odd-numbered padding
+    images = jnp.zeros((1, 256, 320, 3), dtype=jnp.uint8)
+    height = 60
+    width = 80
+    resized_images = image_tools.resize_with_pad(images, height, width)
+    assert resized_images.shape == (1, height, width, 3)
+    assert jnp.all(resized_images == 0)

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/nnx_utils.py

@@ -0,0 +1,69 @@
+from collections.abc import Callable
+import dataclasses
+import functools
+import inspect
+import re
+from typing import Any, ParamSpec, TypeVar
+
+import flax.nnx as nnx
+import jax
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def module_jit(meth: Callable[P, R], *jit_args, **jit_kwargs) -> Callable[P, R]:
+    """A higher-order function to JIT-compile `nnx.Module` methods, freezing the module's state in the process.
+
+    Why not `nnx.jit`? For some reason, naively applying `nnx.jit` to `nnx.Module` methods, bound or unbound, uses much
+    more memory than necessary. I'm guessing it has something to do with the fact that it must keep track of module
+    mutations. Also, `nnx.jit` has some inherent overhead compared to a standard `jax.jit`, since every call must
+    traverse the NNX module graph. See https://github.com/google/flax/discussions/4224 for details.
+
+    `module_jit` is an alternative that avoids these issues by freezing the module's state. The function returned by
+    `module_jit` acts exactly like the original method, except that the state of the module is frozen to whatever it was
+    when `module_jit` was called. Mutations to the module within `meth` are still allowed, but they will be discarded
+    after the method call completes.
+    """
+    if not (inspect.ismethod(meth) and isinstance(meth.__self__, nnx.Module)):
+        raise ValueError("module_jit must only be used on bound methods of nnx.Modules.")
+
+    graphdef, state = nnx.split(meth.__self__)
+
+    def fun(state: nnx.State, *args: P.args, **kwargs: P.kwargs) -> R:
+        module = nnx.merge(graphdef, state)
+        return meth.__func__(module, *args, **kwargs)
+
+    jitted_fn = jax.jit(fun, *jit_args, **jit_kwargs)
+
+    @functools.wraps(meth)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        return jitted_fn(state, *args, **kwargs)
+
+    return wrapper
+
+
+@dataclasses.dataclass(frozen=True)
+class PathRegex:
+    """NNX Filter that matches paths using a regex.
+
+    By default, paths are joined with a `/` separator. This can be overridden by setting the `sep` argument.
+    """
+
+    pattern: str | re.Pattern
+    sep: str = "/"
+
+    def __post_init__(self):
+        if not isinstance(self.pattern, re.Pattern):
+            object.__setattr__(self, "pattern", re.compile(self.pattern))
+
+    def __call__(self, path: nnx.filterlib.PathParts, x: Any) -> bool:
+        joined_path = self.sep.join(str(x) for x in path)
+        assert isinstance(self.pattern, re.Pattern)
+        return self.pattern.fullmatch(joined_path) is not None
+
+
+def state_map(state: nnx.State, filter: nnx.filterlib.Filter, fn: Callable[[Any], Any]) -> nnx.State:
+    """Apply a function to the leaves of the state that match the filter."""
+    filtered_keys = set(state.filter(filter).flat_state())
+    return state.map(lambda k, v: fn(v) if k in filtered_keys else v)

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/normalize.py

@@ -0,0 +1,146 @@
+import json
+import pathlib
+
+import numpy as np
+import numpydantic
+import pydantic
+
+
+@pydantic.dataclasses.dataclass
+class NormStats:
+    mean: numpydantic.NDArray
+    std: numpydantic.NDArray
+    q01: numpydantic.NDArray | None = None  # 1st quantile
+    q99: numpydantic.NDArray | None = None  # 99th quantile
+
+
+class RunningStats:
+    """Compute running statistics of a batch of vectors."""
+
+    def __init__(self):
+        self._count = 0
+        self._mean = None
+        self._mean_of_squares = None
+        self._min = None
+        self._max = None
+        self._histograms = None
+        self._bin_edges = None
+        self._num_quantile_bins = 5000  # for computing quantiles on the fly
+
+    def update(self, batch: np.ndarray) -> None:
+        """
+        Update the running statistics with a batch of vectors.
+
+        Args:
+            vectors (np.ndarray): An array where all dimensions except the last are batch dimensions.
+        """
+        batch = batch.reshape(-1, batch.shape[-1])
+        num_elements, vector_length = batch.shape
+        if self._count == 0:
+            self._mean = np.mean(batch, axis=0)
+            self._mean_of_squares = np.mean(batch**2, axis=0)
+            self._min = np.min(batch, axis=0)
+            self._max = np.max(batch, axis=0)
+            self._histograms = [np.zeros(self._num_quantile_bins) for _ in range(vector_length)]
+            self._bin_edges = [
+                np.linspace(self._min[i] - 1e-10, self._max[i] + 1e-10, self._num_quantile_bins + 1)
+                for i in range(vector_length)
+            ]
+        else:
+            if vector_length != self._mean.size:
+                raise ValueError("The length of new vectors does not match the initialized vector length.")
+            new_max = np.max(batch, axis=0)
+            new_min = np.min(batch, axis=0)
+            max_changed = np.any(new_max > self._max)
+            min_changed = np.any(new_min < self._min)
+            self._max = np.maximum(self._max, new_max)
+            self._min = np.minimum(self._min, new_min)
+
+            if max_changed or min_changed:
+                self._adjust_histograms()
+
+        self._count += num_elements
+
+        batch_mean = np.mean(batch, axis=0)
+        batch_mean_of_squares = np.mean(batch**2, axis=0)
+
+        # Update running mean and mean of squares.
+        self._mean += (batch_mean - self._mean) * (num_elements / self._count)
+        self._mean_of_squares += (batch_mean_of_squares - self._mean_of_squares) * (num_elements / self._count)
+
+        self._update_histograms(batch)
+
+    def get_statistics(self) -> NormStats:
+        """
+        Compute and return the statistics of the vectors processed so far.
+
+        Returns:
+            dict: A dictionary containing the computed statistics.
+        """
+        if self._count < 2:
+            raise ValueError("Cannot compute statistics for less than 2 vectors.")
+
+        variance = self._mean_of_squares - self._mean**2
+        stddev = np.sqrt(np.maximum(0, variance))
+        q01, q99 = self._compute_quantiles([0.01, 0.99])
+        return NormStats(mean=self._mean, std=stddev, q01=q01, q99=q99)
+
+    def _adjust_histograms(self):
+        """Adjust histograms when min or max changes."""
+        for i in range(len(self._histograms)):
+            old_edges = self._bin_edges[i]
+            new_edges = np.linspace(self._min[i], self._max[i], self._num_quantile_bins + 1)
+
+            # Redistribute the existing histogram counts to the new bins
+            new_hist, _ = np.histogram(old_edges[:-1], bins=new_edges, weights=self._histograms[i])
+
+            self._histograms[i] = new_hist
+            self._bin_edges[i] = new_edges
+
+    def _update_histograms(self, batch: np.ndarray) -> None:
+        """Update histograms with new vectors."""
+        for i in range(batch.shape[1]):
+            hist, _ = np.histogram(batch[:, i], bins=self._bin_edges[i])
+            self._histograms[i] += hist
+
+    def _compute_quantiles(self, quantiles):
+        """Compute quantiles based on histograms."""
+        results = []
+        for q in quantiles:
+            target_count = q * self._count
+            q_values = []
+            for hist, edges in zip(self._histograms, self._bin_edges, strict=True):
+                cumsum = np.cumsum(hist)
+                idx = np.searchsorted(cumsum, target_count)
+                q_values.append(edges[idx])
+            results.append(np.array(q_values))
+        return results
+
+
+class _NormStatsDict(pydantic.BaseModel):
+    norm_stats: dict[str, NormStats]
+
+
+def serialize_json(norm_stats: dict[str, NormStats]) -> str:
+    """Serialize the running statistics to a JSON string."""
+    return _NormStatsDict(norm_stats=norm_stats).model_dump_json(indent=2)
+
+
+def deserialize_json(data: str) -> dict[str, NormStats]:
+    """Deserialize the running statistics from a JSON string."""
+    return _NormStatsDict(**json.loads(data)).norm_stats
+
+
+def save(directory: pathlib.Path | str, norm_stats: dict[str, NormStats]) -> None:
+    """Save the normalization stats to a directory."""
+    path = pathlib.Path(directory) / "norm_stats.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(serialize_json(norm_stats))
+
+
+def load(directory: pathlib.Path | str) -> dict[str, NormStats]:
+    """Load the normalization stats from a directory."""
+    path = pathlib.Path(directory) / "norm_stats.json"
+    if not path.exists():
+        raise FileNotFoundError(f"Norm stats file not found at: {path}")
+    return deserialize_json(path.read_text())

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/shared/normalize_test.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+import openpi.shared.normalize as normalize
+
+
+def test_normalize_update():
+    arr = np.arange(12).reshape(4, 3)  # 4 vectors of length 3
+
+    stats = normalize.RunningStats()
+    for i in range(len(arr)):
+        stats.update(arr[i : i + 1])  # Update with one vector at a time
+    results = stats.get_statistics()
+
+    assert np.allclose(results.mean, np.mean(arr, axis=0))
+    assert np.allclose(results.std, np.std(arr, axis=0))
+
+
+def test_serialize_deserialize():
+    stats = normalize.RunningStats()
+    stats.update(np.arange(12).reshape(4, 3))  # 4 vectors of length 3
+
+    norm_stats = {"test": stats.get_statistics()}
+    norm_stats2 = normalize.deserialize_json(normalize.serialize_json(norm_stats))
+    assert np.allclose(norm_stats["test"].mean, norm_stats2["test"].mean)
+    assert np.allclose(norm_stats["test"].std, norm_stats2["test"].std)
+
+
+def test_multiple_batch_dimensions():
+    # Test with multiple batch dimensions: (2, 3, 4) where 4 is vector dimension
+    batch_shape = (2, 3, 4)
+    arr = np.random.rand(*batch_shape)
+
+    stats = normalize.RunningStats()
+    stats.update(arr)  # Should handle (2, 3, 4) -> reshape to (6, 4)
+    results = stats.get_statistics()
+
+    # Flatten batch dimensions and compute expected stats
+    flattened = arr.reshape(-1, arr.shape[-1])  # (6, 4)
+    expected_mean = np.mean(flattened, axis=0)
+    expected_std = np.std(flattened, axis=0)
+
+    assert np.allclose(results.mean, expected_mean)
+    assert np.allclose(results.std, expected_std)

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/transforms.py

@@ -0,0 +1,495 @@
+from collections.abc import Callable, Mapping, Sequence
+import dataclasses
+import re
+from typing import Protocol, TypeAlias, TypeVar, runtime_checkable
+
+import flax.traverse_util as traverse_util
+import jax
+import numpy as np
+from openpi_client import image_tools
+
+from openpi.models import tokenizer as _tokenizer
+from openpi.shared import array_typing as at
+from openpi.shared import normalize as _normalize
+
+DataDict: TypeAlias = at.PyTree
+NormStats: TypeAlias = _normalize.NormStats
+
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+
+@runtime_checkable
+class DataTransformFn(Protocol):
+    def __call__(self, data: DataDict) -> DataDict:
+        """Apply transformation to the data.
+
+        Args:
+            data: The data to apply the transform to. This is a possibly nested dictionary that contains
+                unbatched data elements. Each leaf is expected to be a numpy array. Using JAX arrays is allowed
+                but not recommended since it may result in extra GPU memory usage inside data loader worker
+                processes.
+
+        Returns:
+            The transformed data. Could be the input `data` that was modified in place, or a new data structure.
+        """
+
+
+@dataclasses.dataclass(frozen=True)
+class Group:
+    """A group of transforms."""
+
+    # Transforms that are applied to the model input data.
+    inputs: Sequence[DataTransformFn] = ()
+
+    # Transforms that are applied to the model output data.
+    outputs: Sequence[DataTransformFn] = ()
+
+    def push(self, *, inputs: Sequence[DataTransformFn] = (), outputs: Sequence[DataTransformFn] = ()) -> "Group":
+        """Append transforms to the group and return a new group.
+
+        Args:
+            inputs: Appended to the *end* of the current input transforms.
+            outputs: Appended to the *beginning* of the current output transforms.
+
+        Returns:
+            A new group with the appended transforms.
+        """
+        return Group(inputs=(*self.inputs, *inputs), outputs=(*outputs, *self.outputs))
+
+
+@dataclasses.dataclass(frozen=True)
+class CompositeTransform(DataTransformFn):
+    """A composite transform that applies a sequence of transforms in order."""
+
+    transforms: Sequence[DataTransformFn]
+
+    def __call__(self, data: DataDict) -> DataDict:
+        for transform in self.transforms:
+            data = transform(data)
+        return data
+
+
+def compose(transforms: Sequence[DataTransformFn]) -> DataTransformFn:
+    """Compose a sequence of transforms into a single transform."""
+    return CompositeTransform(transforms)
+
+
+@dataclasses.dataclass(frozen=True)
+class RepackTransform(DataTransformFn):
+    """Repacks an input dictionary into a new dictionary.
+
+    Repacking is defined using a dictionary where the keys are the new keys and the values
+    are the flattened paths to the old keys. We use '/' as the separator during flattening.
+
+    Example:
+    {
+        "images": {
+            "cam_high": "observation.images.top",
+            "cam_low": "observation.images.bottom",
+        },
+        "state": "observation.state",
+        "actions": "action",
+    }
+    """
+
+    structure: at.PyTree[str]
+
+    def __call__(self, data: DataDict) -> DataDict:
+        flat_item = flatten_dict(data)
+        return jax.tree.map(lambda k: flat_item[k], self.structure)
+
+
+@dataclasses.dataclass(frozen=True)
+class InjectDefaultPrompt(DataTransformFn):
+    prompt: str | None
+
+    def __call__(self, data: DataDict) -> DataDict:
+        if self.prompt is not None and "prompt" not in data:
+            data["prompt"] = np.asarray(self.prompt)
+        return data
+
+
+@dataclasses.dataclass(frozen=True)
+class Normalize(DataTransformFn):
+    norm_stats: at.PyTree[NormStats] | None
+    # If true, will use quantile normalization. Otherwise, normal z-score normalization will be used.
+    use_quantiles: bool = False
+    # If true, will raise an error if any of the keys in the norm stats are not present in the data.
+    strict: bool = False
+
+    def __post_init__(self):
+        if self.norm_stats is not None and self.use_quantiles:
+            _assert_quantile_stats(self.norm_stats)
+
+    def __call__(self, data: DataDict) -> DataDict:
+        if self.norm_stats is None:
+            return data
+
+        return apply_tree(
+            data,
+            self.norm_stats,
+            self._normalize_quantile if self.use_quantiles else self._normalize,
+            strict=self.strict,
+        )
+
+    def _normalize(self, x, stats: NormStats):
+        mean, std = stats.mean[..., : x.shape[-1]], stats.std[..., : x.shape[-1]]
+        return (x - mean) / (std + 1e-6)
+
+    def _normalize_quantile(self, x, stats: NormStats):
+        assert stats.q01 is not None
+        assert stats.q99 is not None
+        q01, q99 = stats.q01[..., : x.shape[-1]], stats.q99[..., : x.shape[-1]]
+        return (x - q01) / (q99 - q01 + 1e-6) * 2.0 - 1.0
+
+
+@dataclasses.dataclass(frozen=True)
+class Unnormalize(DataTransformFn):
+    norm_stats: at.PyTree[NormStats] | None
+    # If true, will use quantile normalization. Otherwise, normal z-score normalization will be used.
+    use_quantiles: bool = False
+
+    def __post_init__(self):
+        if self.norm_stats is not None and self.use_quantiles:
+            _assert_quantile_stats(self.norm_stats)
+
+    def __call__(self, data: DataDict) -> DataDict:
+        if self.norm_stats is None:
+            return data
+
+        # Make sure that all the keys in the norm stats are present in the data.
+        return apply_tree(
+            data,
+            self.norm_stats,
+            self._unnormalize_quantile if self.use_quantiles else self._unnormalize,
+            strict=True,
+        )
+
+    def _unnormalize(self, x, stats: NormStats):
+        mean = pad_to_dim(stats.mean, x.shape[-1], axis=-1, value=0.0)
+        std = pad_to_dim(stats.std, x.shape[-1], axis=-1, value=1.0)
+        return x * (std + 1e-6) + mean
+
+    def _unnormalize_quantile(self, x, stats: NormStats):
+        assert stats.q01 is not None
+        assert stats.q99 is not None
+        q01, q99 = stats.q01, stats.q99
+        if (dim := q01.shape[-1]) < x.shape[-1]:
+            return np.concatenate([(x[..., :dim] + 1.0) / 2.0 * (q99 - q01 + 1e-6) + q01, x[..., dim:]], axis=-1)
+        return (x + 1.0) / 2.0 * (q99 - q01 + 1e-6) + q01
+
+
+@dataclasses.dataclass(frozen=True)
+class ResizeImages(DataTransformFn):
+    height: int
+    width: int
+
+    def __call__(self, data: DataDict) -> DataDict:
+        data["image"] = {k: image_tools.resize_with_pad(v, self.height, self.width) for k, v in data["image"].items()}
+        return data
+
+
+@dataclasses.dataclass(frozen=True)
+class SubsampleActions(DataTransformFn):
+    stride: int
+
+    def __call__(self, data: DataDict) -> DataDict:
+        data["actions"] = data["actions"][:: self.stride]
+        return data
+
+
+@dataclasses.dataclass(frozen=True)
+class DeltaActions(DataTransformFn):
+    """Repacks absolute actions into delta action space."""
+
+    # Boolean mask for the action dimensions to be repacked into delta action space. Length
+    # can be smaller than the actual number of dimensions. If None, this transform is a no-op.
+    # See `make_bool_mask` for more details.
+    mask: Sequence[bool] | None
+
+    def __call__(self, data: DataDict) -> DataDict:
+        if "actions" not in data or self.mask is None:
+            return data
+
+        state, actions = data["state"], data["actions"]
+        mask = np.asarray(self.mask)
+        dims = mask.shape[-1]
+        actions[..., :dims] -= np.expand_dims(np.where(mask, state[..., :dims], 0), axis=-2)
+        data["actions"] = actions
+
+        return data
+
+
+@dataclasses.dataclass(frozen=True)
+class AbsoluteActions(DataTransformFn):
+    """Repacks delta actions into absolute action space."""
+
+    # Boolean mask for the action dimensions to be repacked into absolute action space. Length
+    # can be smaller than the actual number of dimensions. If None, this transform is a no-op.
+    # See `make_bool_mask` for more details.
+    mask: Sequence[bool] | None
+
+    def __call__(self, data: DataDict) -> DataDict:
+        if "actions" not in data or self.mask is None:
+            return data
+
+        state, actions = data["state"], data["actions"]
+        mask = np.asarray(self.mask)
+        dims = mask.shape[-1]
+        actions[..., :dims] += np.expand_dims(np.where(mask, state[..., :dims], 0), axis=-2)
+        data["actions"] = actions
+
+        return data
+
+
+@dataclasses.dataclass(frozen=True)
+class TokenizePrompt(DataTransformFn):
+    tokenizer: _tokenizer.PaligemmaTokenizer
+    discrete_state_input: bool = False
+
+    def __call__(self, data: DataDict) -> DataDict:
+        if (prompt := data.pop("prompt", None)) is None:
+            raise ValueError("Prompt is required")
+
+        # InjectDefaultPrompt stores a single default string as a zero-dimensional
+        # ndarray. Treat that as a scalar prompt, not as a batch (``list`` on a
+        # 0-D array raises TypeError during policy inference).
+        is_batched_prompt = isinstance(prompt, list) or (
+            isinstance(prompt, (np.ndarray, jax.Array)) and np.ndim(prompt) > 0
+        )
+
+        if self.discrete_state_input:
+            if (state := data.get("state", None)) is None:
+                raise ValueError("State is required.")
+        else:
+            state = None
+
+        if is_batched_prompt:
+            prompts = list(prompt)
+            states = state if self.discrete_state_input else [None] * len(prompts)
+            token_list = []
+            mask_list = []
+            for prompt_item, state_item in zip(prompts, states, strict=True):
+                if not isinstance(prompt_item, str):
+                    prompt_item = prompt_item.item()
+                tokens, token_masks = self.tokenizer.tokenize(prompt_item, state_item)
+                token_list.append(tokens)
+                mask_list.append(token_masks)
+            tokens = np.stack(token_list)
+            token_masks = np.stack(mask_list)
+        else:
+            if not isinstance(prompt, str):
+                prompt = prompt.item()
+            tokens, token_masks = self.tokenizer.tokenize(prompt, state)
+
+        return {**data, "tokenized_prompt": tokens, "tokenized_prompt_mask": token_masks}
+
+
+@dataclasses.dataclass(frozen=True)
+class TokenizeFASTInputs(DataTransformFn):
+    tokenizer: _tokenizer.FASTTokenizer
+
+    def __call__(self, data: DataDict) -> DataDict:
+        if (prompt := data.pop("prompt", None)) is None:
+            raise ValueError("Prompt is required")
+
+        if not isinstance(prompt, str):
+            prompt = prompt.item()
+
+        state, actions = data["state"], data.get("actions")
+        tokens, token_mask, ar_mask, loss_mask = self.tokenizer.tokenize(prompt, state, actions)
+        return {
+            **data,
+            "tokenized_prompt": tokens,
+            "tokenized_prompt_mask": token_mask,
+            "token_ar_mask": ar_mask,
+            "token_loss_mask": loss_mask,
+        }
+
+
+@dataclasses.dataclass(frozen=True)
+class ExtractFASTActions(DataTransformFn):
+    tokenizer: _tokenizer.FASTTokenizer
+    action_horizon: int
+    action_dim: int
+
+    def __call__(self, data: DataDict) -> DataDict:
+        if "actions" not in data:
+            return data
+        # Model outputs are saved in "actions", but for FAST models they represent tokens.
+        tokens = data.pop("actions")
+        actions = self.tokenizer.extract_actions(tokens.astype(np.int32), self.action_horizon, self.action_dim)
+        return {
+            **data,
+            "actions": actions,
+        }
+
+
+@dataclasses.dataclass(frozen=True)
+class PromptFromLeRobotTask(DataTransformFn):
+    """Extracts a prompt from the current LeRobot dataset task."""
+
+    # Contains the LeRobot dataset tasks (dataset.meta.tasks).
+    tasks: object
+
+    def _get_prompt(self, task_index: int) -> str | None:
+        if isinstance(self.tasks, Mapping):
+            prompt = self.tasks.get(task_index)
+            return None if prompt is None else str(prompt)
+
+        columns = getattr(self.tasks, "columns", None)
+        index = getattr(self.tasks, "index", None)
+        if columns is not None and index is not None and "task_index" in columns:
+            matches = index[self.tasks["task_index"] == task_index]
+            if len(matches) > 0:
+                return str(matches[0])
+
+        return None
+
+    def __call__(self, data: DataDict) -> DataDict:
+        if "task_index" not in data:
+            raise ValueError('Cannot extract prompt without "task_index"')
+
+        task_index = int(data["task_index"])
+        if (prompt := self._get_prompt(task_index)) is None:
+            raise ValueError(f"{task_index=} not found in task mapping: {self.tasks}")
+
+        return {**data, "prompt": prompt}
+
+
+@dataclasses.dataclass(frozen=True)
+class PadStatesAndActions(DataTransformFn):
+    """Zero-pads states and actions to the model action dimension."""
+
+    model_action_dim: int
+
+    def __call__(self, data: DataDict) -> DataDict:
+        data["state"] = pad_to_dim(data["state"], self.model_action_dim, axis=-1)
+        if "actions" in data:
+            data["actions"] = pad_to_dim(data["actions"], self.model_action_dim, axis=-1)
+        return data
+
+
+def flatten_dict(tree: at.PyTree) -> dict:
+    """Flatten a nested dictionary. Uses '/' as the separator."""
+    return traverse_util.flatten_dict(tree, sep="/")
+
+
+def unflatten_dict(tree: dict) -> at.PyTree:
+    """Unflatten a flattened dictionary. Assumes that '/' was used as a separator."""
+    return traverse_util.unflatten_dict(tree, sep="/")
+
+
+def transform_dict(patterns: Mapping[str, str | None], tree: at.PyTree) -> at.PyTree:
+    """Transform the structure of a nested dictionary using a set of patterns.
+
+    The transformation is defined using the `patterns` dictionary. The keys are the
+    input keys that should be matched and the values are the new names inside the output
+    dictionary. If the value is None, the input key is removed.
+
+    Both keys and values should represent flattened paths using '/' as the separator.
+    Keys can be regular expressions and values can include backreferences to the
+    matched groups (see `re.sub` for more details). Note that the regular expression
+    must match the entire key.
+
+    The order inside the `patterns` dictionary is important. Only the first pattern that
+    matches the input key will be used.
+
+    See unit tests for more examples.
+
+    Args:
+        patterns: A mapping from old keys to new keys.
+        tree: The nested dictionary to transform.
+
+    Returns:
+        The transformed nested dictionary.
+    """
+    data = flatten_dict(tree)
+
+    # Compile the patterns.
+    compiled = {re.compile(k): v for k, v in patterns.items()}
+
+    output = {}
+    for k in data:
+        for pattern, repl in compiled.items():
+            if pattern.fullmatch(k):
+                new_k = pattern.sub(repl, k, count=1) if repl is not None else None
+                break
+        else:
+            # Use the original key if no match is found.
+            new_k = k
+
+        if new_k is not None:
+            if new_k in output:
+                raise ValueError(f"Key '{new_k}' already exists in output")
+            output[new_k] = data[k]
+
+    # Validate the output structure to make sure that it can be unflattened.
+    names = sorted(output)
+    for i in range(len(names) - 1):
+        name, next_name = names[i : i + 2]
+        if next_name.startswith(name + "/"):
+            raise ValueError(f"Leaf '{name}' aliases a node of '{next_name}'")
+
+    return unflatten_dict(output)
+
+
+def apply_tree(
+    tree: at.PyTree[T], selector: at.PyTree[S], fn: Callable[[T, S], T], *, strict: bool = False
+) -> at.PyTree[T]:
+    tree = flatten_dict(tree)
+    selector = flatten_dict(selector)
+
+    def transform(k: str, v: T) -> T:
+        if k in selector:
+            return fn(v, selector[k])
+        return v
+
+    if strict:
+        for k in selector:
+            if k not in tree:
+                raise ValueError(f"Selector key {k} not found in tree")
+
+    return unflatten_dict({k: transform(k, v) for k, v in tree.items()})
+
+
+def pad_to_dim(x: np.ndarray, target_dim: int, axis: int = -1, value: float = 0.0) -> np.ndarray:
+    """Pad an array to the target dimension with zeros along the specified axis."""
+    current_dim = x.shape[axis]
+    if current_dim < target_dim:
+        pad_width = [(0, 0)] * len(x.shape)
+        pad_width[axis] = (0, target_dim - current_dim)
+        return np.pad(x, pad_width, constant_values=value)
+    return x
+
+
+def make_bool_mask(*dims: int) -> tuple[bool, ...]:
+    """Make a boolean mask for the given dimensions.
+
+    Example:
+        make_bool_mask(2, -2, 2) == (True, True, False, False, True, True)
+        make_bool_mask(2, 0, 2) == (True, True, True, True)
+
+    Args:
+        dims: The dimensions to make the mask for.
+
+    Returns:
+        A tuple of booleans.
+    """
+    result = []
+    for dim in dims:
+        if dim > 0:
+            result.extend([True] * (dim))
+        else:
+            result.extend([False] * (-dim))
+    return tuple(result)
+
+
+def _assert_quantile_stats(norm_stats: at.PyTree[NormStats]) -> None:
+    for k, v in flatten_dict(norm_stats).items():
+        if v.q01 is None or v.q99 is None:
+            raise ValueError(
+                f"quantile stats must be provided if use_quantile_norm is True. Key {k} is missing q01 or q99."
+            )

real_inference/source/XPolicyLab/policy/Pi_05/openpi/src/openpi/transforms_test.py

@@ -0,0 +1,141 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+import openpi.models.tokenizer as _tokenizer
+import openpi.transforms as _transforms
+
+
+def test_repack_transform():
+    transform = _transforms.RepackTransform(
+        structure={
+            "a": {"b": "b/c"},
+            "d": "e/f",
+        }
+    )
+    item = {"b": {"c": 1}, "e": {"f": 2}}
+    assert transform(item) == {"a": {"b": 1}, "d": 2}
+
+
+def test_delta_actions():
+    item = {"state": np.array([1, 2, 3]), "actions": np.array([[3, 4, 5], [5, 6, 7]])}
+
+    transform = _transforms.DeltaActions(mask=[False, True])
+    transformed = transform(item)
+
+    assert np.all(transformed["state"] == np.array([1, 2, 3]))
+    assert np.all(transformed["actions"] == np.array([[3, 2, 5], [5, 4, 7]]))
+
+
+def test_delta_actions_noop():
+    item = {"state": np.array([1, 2, 3]), "actions": np.array([[3, 4, 5], [5, 6, 7]])}
+
+    # No-op when the mask is disabled.
+    transform = _transforms.DeltaActions(mask=None)
+    assert transform(item) is item
+
+    # No-op when there are no actions in the input.
+    del item["actions"]
+    transform = _transforms.DeltaActions(mask=[True, False])
+    assert transform(item) is item
+
+
+def test_absolute_actions():
+    item = {"state": np.array([1, 2, 3]), "actions": np.array([[3, 4, 5], [5, 6, 7]])}
+
+    transform = _transforms.AbsoluteActions(mask=[False, True])
+    transformed = transform(item)
+
+    assert np.all(transformed["state"] == np.array([1, 2, 3]))
+    assert np.all(transformed["actions"] == np.array([[3, 6, 5], [5, 8, 7]]))
+
+
+def test_absolute_actions_noop():
+    item = {"state": np.array([1, 2, 3]), "actions": np.array([[3, 4, 5], [5, 6, 7]])}
+
+    # No-op when the mask is disabled.
+    transform = _transforms.AbsoluteActions(mask=None)
+    assert transform(item) is item
+
+    # No-op when there are no actions in the input.
+    del item["actions"]
+    transform = _transforms.AbsoluteActions(mask=[True, False])
+    assert transform(item) is item
+
+
+def test_make_bool_mask():
+    assert _transforms.make_bool_mask(2, -2, 2) == (True, True, False, False, True, True)
+    assert _transforms.make_bool_mask(2, 0, 2) == (True, True, True, True)
+
+
+def test_tokenize_prompt():
+    tokenizer = _tokenizer.PaligemmaTokenizer(max_len=12)
+    transform = _transforms.TokenizePrompt(tokenizer)
+
+    data = transform({"prompt": "Hello, world!"})
+
+    tok_prompt, tok_mask = tokenizer.tokenize("Hello, world!")
+    assert np.allclose(tok_prompt, data["tokenized_prompt"])
+    assert np.allclose(tok_mask, data["tokenized_prompt_mask"])
+
+
+def test_tokenize_scalar_array_prompt():
+    tokenizer = _tokenizer.PaligemmaTokenizer(max_len=12)
+    transform = _transforms.TokenizePrompt(tokenizer)
+
+    data = transform({"prompt": np.asarray("Fold the T-shirt.")})
+
+    tok_prompt, tok_mask = tokenizer.tokenize("Fold the T-shirt.")
+    assert np.allclose(tok_prompt, data["tokenized_prompt"])
+    assert np.allclose(tok_mask, data["tokenized_prompt_mask"])
+
+
+def test_tokenize_no_prompt():
+    transform = _transforms.TokenizePrompt(_tokenizer.PaligemmaTokenizer())
+
+    with pytest.raises(ValueError, match="Prompt is required"):
+        transform({})
+
+
+def test_transform_dict():
+    # Rename and remove keys.
+    input = {"a": {"b": 1, "c": 2}}
+    output = _transforms.transform_dict({"a/b": "a/c", "a/c": None}, input)
+    assert output == {"a": {"c": 1}}
+
+    # Raises and error since the renamed key conflicts with an existing key.
+    with pytest.raises(ValueError, match="Key 'a/c' already exists in output"):
+        _transforms.transform_dict({"a/b": "a/c"}, input)
+
+    # Full match is required and so nothing will be removed.
+    input = {"a": {"b": 1, "c": 2}}
+    output = _transforms.transform_dict({"a": None}, input)
+    assert output == input
+
+    # The regex matches the entire key and so the entire input will be removed.
+    input = {"a": {"b": 1, "c": 2}}
+    output = _transforms.transform_dict({"a.+": None}, input)
+    assert output == {}
+
+    # Replace keys using backreferences. All leaves named 'c' are replaced with 'd'.
+    input = {"a": {"b": 1, "c": 1}, "b": {"c": 2}}
+    output = _transforms.transform_dict({"(.+)/c": r"\1/d"}, input)
+    assert output == {"a": {"b": 1, "d": 1}, "b": {"d": 2}}
+
+
+def test_extract_prompt_from_task():
+    transform = _transforms.PromptFromLeRobotTask({1: "Hello, world!"})
+
+    data = transform({"task_index": 1})
+    assert data["prompt"] == "Hello, world!"
+
+    with pytest.raises(ValueError, match="task_index=2 not found in task mapping"):
+        transform({"task_index": 2})
+
+
+def test_extract_prompt_from_task_dataframe():
+    tasks = pd.DataFrame({"task_index": [0, 1]}, index=["Task zero", "Hello, world!"])
+    transform = _transforms.PromptFromLeRobotTask(tasks)
+
+    data = transform({"task_index": 1})
+    assert data["prompt"] == "Hello, world!"

real_inference/source/xpolicylab_local_changes.patch

@@ -0,0 +1,467 @@
+diff --git a/policy/ACT/imitate_episodes.py b/policy/ACT/imitate_episodes.py
+index 9d87e43..f26be34 100644
+--- a/policy/ACT/imitate_episodes.py
++++ b/policy/ACT/imitate_episodes.py
+@@ -37,9 +37,13 @@ def main(args):
+     num_epochs = args["num_epochs"]
+ 
+     # get task parameters
+-    from constants import TASK_CONFIGS
+-
+-    task_config = TASK_CONFIGS[ckpt_setting]
++    aloha_manifest = os.environ.get("ALOHA_POLICY_MANIFEST")
++    if aloha_manifest:
++        task_config = {"dataset_dir": "", "num_episodes": 0, "episode_len": 0,
++                       "camera_names": ["cam_high", "cam_left_wrist", "cam_right_wrist"]}
++    else:
++        from constants import TASK_CONFIGS
++        task_config = TASK_CONFIGS[ckpt_setting]
+     dataset_dir = task_config["dataset_dir"]
+     num_episodes = task_config["num_episodes"]
+     episode_len = task_config["episode_len"]
+@@ -93,8 +97,11 @@ def main(args):
+         "save_freq": args['save_freq']
+     }
+ 
+-    train_dataloader, val_dataloader, stats, _ = load_data(dataset_dir, num_episodes, camera_names, batch_size_train,
+-                                                           batch_size_val)
++    if aloha_manifest:
++        from aloha_dataset import act_load_data
++        train_dataloader, val_dataloader, stats, _ = act_load_data(aloha_manifest, batch_size_train, batch_size_val, args["chunk_size"])
++    else:
++        train_dataloader, val_dataloader, stats, _ = load_data(dataset_dir, num_episodes, camera_names, batch_size_train, batch_size_val)
+ 
+     # save dataset stats
+     if not os.path.isdir(ckpt_dir):
+@@ -204,6 +211,8 @@ def train_bc(train_dataloader, val_dataloader, config):
+         for k, v in epoch_summary.items():
+             summary_string += f"{k}: {v.item():.3f} "
+ 
++        print(f"epoch {epoch + 1}/{num_epochs}: train_loss={epoch_summary['loss'].item():.6f} val_loss={epoch_val_loss.item():.6f}", flush=True)
++
+         if (epoch + 1) % config['save_freq'] == 0:
+             ckpt_path = os.path.join(ckpt_dir, f"policy_epoch_{epoch + 1}_seed_{seed}.ckpt")
+             torch.save(policy.state_dict(), ckpt_path)
+@@ -211,6 +220,11 @@ def train_bc(train_dataloader, val_dataloader, config):
+     ckpt_path = os.path.join(ckpt_dir, f"policy_last.ckpt")
+     torch.save(policy.state_dict(), ckpt_path)
+ 
++    if best_ckpt_info is not None:
++        best_epoch, best_val_loss, best_state_dict = best_ckpt_info
++        torch.save(best_state_dict, os.path.join(ckpt_dir, "policy_best.ckpt"))
++        print(f"best validation: epoch {best_epoch + 1}, loss={best_val_loss.item():.6f}", flush=True)
++
+     # best_epoch, min_val_loss, best_state_dict = best_ckpt_info
+     # ckpt_path = os.path.join(ckpt_dir, f"policy_epoch_{best_epoch}_seed_{seed}.ckpt")
+     # torch.save(best_state_dict, ckpt_path)
+diff --git a/policy/DP/diffusion_policy/dataset/robot_image_dataset.py b/policy/DP/diffusion_policy/dataset/robot_image_dataset.py
+index 49ab621..17918e8 100644
+--- a/policy/DP/diffusion_policy/dataset/robot_image_dataset.py
++++ b/policy/DP/diffusion_policy/dataset/robot_image_dataset.py
+@@ -26,16 +26,21 @@ class RobotImageDataset(BaseImageDataset):
+         val_ratio=0.0,
+         batch_size=128,
+         max_train_episodes=None,
++        aloha_manifest_split=False,
+     ):
+ 
+         super().__init__()
+-        self.replay_buffer = ReplayBuffer.copy_from_path(
+-            zarr_path,
+-            keys=["head_camera", "left_camera", "right_camera", "state", "action"],
+-        )
++        if aloha_manifest_split:
++            self.replay_buffer = ReplayBuffer.create_from_path(zarr_path, mode="r")
++            if not self.replay_buffer.root.attrs.get("complete", False):
++                raise ValueError("Incomplete Aloha Zarr conversion")
++        else:
++            self.replay_buffer = ReplayBuffer.copy_from_path(
++                zarr_path, keys=["head_camera", "left_camera", "right_camera", "state", "action"])
++        self.aloha_manifest_split = aloha_manifest_split
+ 
+         val_mask = get_val_mask(n_episodes=self.replay_buffer.n_episodes, val_ratio=val_ratio, seed=seed)
+-        train_mask = ~val_mask
++        train_mask = np.asarray(self.replay_buffer.root["meta/train_mask"][:], dtype=bool) if aloha_manifest_split else ~val_mask
+         train_mask = downsample_mask(mask=train_mask, max_n=max_train_episodes, seed=seed)
+ 
+         self.sampler = SequenceSampler(
+@@ -58,7 +63,8 @@ class RobotImageDataset(BaseImageDataset):
+         }
+         self.buffers_torch = {k: torch.from_numpy(v) for k, v in self.buffers.items()}
+         for v in self.buffers_torch.values():
+-            v.pin_memory()
++            if torch.cuda.is_available():
++                v.pin_memory()
+ 
+     def get_validation_dataset(self):
+         val_set = copy.copy(self)
+@@ -73,10 +79,13 @@ class RobotImageDataset(BaseImageDataset):
+         return val_set
+ 
+     def get_normalizer(self, mode="limits", **kwargs):
+-        data = {
+-            "action": self.replay_buffer["action"],
+-            "agent_pos": self.replay_buffer["state"],
+-        }
++        if self.aloha_manifest_split:
++            ends = self.replay_buffer.episode_ends[:]
++            starts = np.r_[0, ends[:-1]]
++            data = {key: np.concatenate([self.replay_buffer[src][int(a):int(b)] for a, b, keep in zip(starts, ends, self.train_mask) if keep])
++                    for key, src in (("action", "action"), ("agent_pos", "state"))}
++        else:
++            data = {"action": self.replay_buffer["action"], "agent_pos": self.replay_buffer["state"]}
+         normalizer = LinearNormalizer()
+         normalizer.fit(data=data, last_n_dims=1, mode=mode, **kwargs)
+         normalizer["head_cam"] = get_image_range_normalizer()
+@@ -115,6 +124,9 @@ class RobotImageDataset(BaseImageDataset):
+             sample = dict_apply(sample, torch.from_numpy)
+             return sample
+         elif isinstance(idx, np.ndarray):
++            if self.aloha_manifest_split:
++                samples = [self.sampler.sample_sequence(int(i)) for i in idx]
++                return {key: torch.from_numpy(np.stack([s[key] for s in samples])) for key in samples[0]}
+             assert len(idx) == self.batch_size
+             for k, v in self.sampler.replay_buffer.items():
+                 batch_sample_sequence(
+diff --git a/policy/Pi_05/openpi/src/openpi/shared/download.py b/policy/Pi_05/openpi/src/openpi/shared/download.py
+index 582f839..2931988 100644
+--- a/policy/Pi_05/openpi/src/openpi/shared/download.py
++++ b/policy/Pi_05/openpi/src/openpi/shared/download.py
+@@ -85,6 +85,16 @@ def maybe_download(url: str, *, force_download: bool = False, **kwargs) -> pathl
+                 # Download the data to a local cache.
+                 logger.info(f"Downloading {url} to {local_path}")
+                 scratch_path = local_path.with_suffix(".partial")
++                # A previously interrupted transfer can leave this scratch path
++                # behind. fsspec then nests a fresh recursive download inside
++                # it, while stale truncated shards remain at its root. Start a
++                # new download from an empty scratch path instead.
++                if scratch_path.exists():
++                    logger.warning(f"Removing stale partial download: {scratch_path}")
++                    if scratch_path.is_dir():
++                        shutil.rmtree(scratch_path)
++                    else:
++                        scratch_path.unlink()
+                 # Route openpi-assets through gsutil to avoid gcsfs auth issues with this bucket.
+                 # All other gs:// URLs (e.g. big_vision) continue to use gcsfs as normal.
+                 if parsed.scheme == "gs" and parsed.netloc == "openpi-assets":
+diff --git a/policy/Pi_05/openpi/src/openpi/training/config.py b/policy/Pi_05/openpi/src/openpi/training/config.py
+index c6babbc..fbc7301 100644
+--- a/policy/Pi_05/openpi/src/openpi/training/config.py
++++ b/policy/Pi_05/openpi/src/openpi/training/config.py
+@@ -5,6 +5,7 @@ from collections.abc import Sequence
+ import dataclasses
+ import difflib
+ import logging
++import os
+ import pathlib
+ from typing import Any, Literal, Protocol, TypeAlias
+ 
+@@ -20,8 +21,10 @@ import openpi.models.tokenizer as _tokenizer
+ import openpi.policies.aloha_policy as aloha_policy
+ import openpi.policies.droid_policy as droid_policy
+ import openpi.policies.libero_policy as libero_policy
++import openpi.policies.pika_bimanual_policy as pika_bimanual_policy
+ import openpi.policies.wuji_policy as wuji_policy
+ import openpi.shared.download as _download
++import openpi.shared.nnx_utils as nnx_utils
+ import openpi.shared.normalize as _normalize
+ import openpi.training.droid_rlds_dataset as droid_rlds_dataset
+ import openpi.training.misc.polaris_config as polaris_config
+@@ -71,6 +74,11 @@ class AssetsConfig:
+ class DataConfig:
+     # LeRobot repo id. If None, fake data will be created.
+     repo_id: str | None = None
++    # Optional physical root for a local LeRobot dataset. This avoids requiring
++    # the data to be placed below HF_LEROBOT_HOME/<repo_id>.
++    lerobot_root: str | None = None
++    # Optional subset of LeRobot episode indices, applied before sampling.
++    episode_indices: Sequence[int] | None = None
+     # Video decoder backend for LeRobot datasets. Forced to pyav by default because
+     # torchcodec is present in some environments but not fully functional at runtime.
+     video_backend: Literal["pyav", "torchcodec", "video_reader"] = "pyav"
+@@ -424,6 +432,73 @@ class LeRobotWujiDataConfig(DataConfigFactory):
+         )
+ 
+ 
++@dataclasses.dataclass(frozen=True)
++class LeRobotPikaBimanualDataConfig(DataConfigFactory):
++    """Local LeRobot configuration for two-fisheye, 14-D dual-arm Pika data.
++
++    The converter writes absolute next-state targets, therefore action deltas
++    deliberately remain disabled. ``PIKA_LEROBOT_ROOT`` points at the physical
++    local dataset root and can be overridden with ``local_dataset_root``.
++    """
++
++    local_dataset_root: str | None = None
++    episode_indices: Sequence[int] = tuple(range(50))
++    default_prompt: str = "Fold the T-shirt."
++    action_sequence_keys: Sequence[str] = ("action",)
++    # Relative mode removes the arbitrary Pika/Lighthouse world origin. State
++    # is anchored at the current left Pika and each action is a full local
++    # SE(3) transform from that arm's current pose to its future target.
++    relative_pose: bool = False
++
++    @override
++    def create(self, assets_dirs: pathlib.Path, model_config: _model.BaseModelConfig) -> DataConfig:
++        if model_config.action_dim != pika_bimanual_policy.PIKA_BIMANUAL_ACTION_DIM:
++            raise ValueError(
++                "Pika bimanual config requires model.action_dim="
++                f"{pika_bimanual_policy.PIKA_BIMANUAL_ACTION_DIM}, got {model_config.action_dim}."
++            )
++        dataset_root = self.local_dataset_root or os.environ.get("PIKA_LEROBOT_ROOT")
++        if not dataset_root:
++            raise ValueError(
++                "Set PIKA_LEROBOT_ROOT to the local converted LeRobot dataset, or set "
++                "data.local_dataset_root explicitly."
++            )
++
++        repack_transform = _transforms.Group(
++            inputs=[
++                _transforms.RepackTransform(
++                    {
++                        "observation/image": "observation.images.cam_left_wrist",
++                        "observation/wrist_image": "observation.images.cam_right_wrist",
++                        "observation/state": "observation.state",
++                        "actions": "action",
++                        "prompt": "prompt",
++                    }
++                )
++            ]
++        )
++        data_transforms = _transforms.Group(
++            inputs=[
++                pika_bimanual_policy.PikaBimanualInputs(
++                    model_type=model_config.model_type,
++                    relative_pose=self.relative_pose,
++                )
++            ],
++            outputs=[pika_bimanual_policy.PikaBimanualOutputs()],
++        )
++
++        return dataclasses.replace(
++            self.create_base_config(assets_dirs, model_config),
++            lerobot_root=dataset_root,
++            episode_indices=self.episode_indices,
++            repack_transforms=repack_transform,
++            data_transforms=data_transforms,
++            model_transforms=ModelTransformFactory(default_prompt=self.default_prompt)(model_config),
++            action_sequence_keys=self.action_sequence_keys,
++            prompt_from_task=True,
++        )
++
++
+ @dataclasses.dataclass(frozen=True)
+ class RLDSDroidDataConfig(DataConfigFactory):
+     """
+@@ -631,7 +706,43 @@ class TrainConfig:
+ 
+ 
+ # Use `get_config` if you need to get a config by name in your code.
++_PIKA_BIMANUAL_LORA_MODEL = pi0_config.Pi0Config(
++    pi05=True,
++    action_dim=14,
++    action_horizon=16,
++    max_token_len=256,
++    # Train LoRA adapters in both the PaliGemma backbone and action expert.
++    paligemma_variant="gemma_2b_lora",
++    action_expert_variant="gemma_300m_lora",
++)
++
++_ALOHA_GARMENT_MODEL = pi0_config.Pi0Config(
++    pi05=True, paligemma_variant="gemma_2b_lora", action_expert_variant="gemma_300m_lora")
++_ALOHA_GARMENT_ROOT = "/data2/wushuang/my_projects/Aloha2-CollectData-DeformableObject/policy_training"
++
++def _aloha_garment_data(split: str) -> LeRobotAlohaDataConfig:
++    return LeRobotAlohaDataConfig(
++        repo_id=f"local/aloha_garment_{split}",
++        assets=AssetsConfig(asset_id="aloha_garment"),
++        base_config=DataConfig(lerobot_root=f"{_ALOHA_GARMENT_ROOT}/lerobot_{split}", prompt_from_task=True),
++        use_delta_joint_actions=False, adapt_to_pi=False,
++        repack_transforms=_transforms.Group(inputs=[_transforms.RepackTransform({
++            "images": {"cam_high": "observation.images.cam_high", "cam_left_wrist": "observation.images.cam_left_wrist", "cam_right_wrist": "observation.images.cam_right_wrist"},
++            "state": "observation.state", "actions": "action", "prompt": "prompt"})]),
++    )
++
+ _CONFIGS = [
++    TrainConfig(
++        name="pi05_aloha_garment_lora", model=_ALOHA_GARMENT_MODEL,
++        freeze_filter=nnx.Any(
++            _ALOHA_GARMENT_MODEL.get_freeze_filter(),
++            nnx_utils.PathRegex("PaliGemma/img/.*"),
++        ),
++        ema_decay=None,
++        data=_aloha_garment_data("train"),
++        weight_loader=weight_loaders.CheckpointWeightLoader("/data2/wushuang/.cache/openpi/openpi-assets/checkpoints/pi05_base/params"),
++        batch_size=2, num_workers=2, wandb_enabled=False,
++    ),
+     TrainConfig(
+         name="pi05_base_aloha_full_sim_arx-x5_seed_0",
+         model=pi0_config.Pi0Config(pi05=True),
+@@ -768,6 +879,132 @@ _CONFIGS = [
+             decay_lr=5e-6,
+         ),
+     ),
++    # Pika dual-arm T-shirt folding: 14-D absolute next-state targets at 10 Hz.
++    TrainConfig(
++        name="pi05_pika_bimanual_fisheye",
++        model=pi0_config.Pi0Config(pi05=True, action_dim=14, action_horizon=16, max_token_len=256),
++        data=LeRobotPikaBimanualDataConfig(
++            repo_id="pika/fold_cloth_0910_bimanual_fisheye",
++            # Must match compute_norm_stats.py, which writes below repo_id.
++            assets=AssetsConfig(asset_id="pika/fold_cloth_0910_bimanual_fisheye"),
++        ),
++        weight_loader=weight_loaders.PartialCheckpointWeightLoader(
++            "gs://openpi-assets/checkpoints/pi05_base/params"
++        ),
++        # The launchers set this to pika_manip/data/openpi_assets. Keeping the
++        # default permits a standalone OpenPI checkout to use ./assets instead.
++        assets_base_dir=os.environ.get("PIKA_OPENPI_ASSETS_BASE_DIR", "./assets"),
++        num_train_steps=30_000,
++        batch_size=64,
++        num_workers=4,
++        lr_schedule=_optimizer.CosineDecaySchedule(
++            warmup_steps=1_000,
++            peak_lr=5e-5,
++            decay_steps=30_000,
++            decay_lr=5e-6,
++        ),
++    ),
++    # Single-GPU-friendly LoRA alternative to the full Pika fine-tune above.
++    # It reuses the same local 50-episode train split and normalization stats.
++    TrainConfig(
++        name="pi05_pika_bimanual_fisheye_lora",
++        model=_PIKA_BIMANUAL_LORA_MODEL,
++        freeze_filter=nnx.Any(
++            _PIKA_BIMANUAL_LORA_MODEL.get_freeze_filter(),
++            # The ViT is not a LoRA module in OpenPI. Freeze it explicitly so
++            # this is adapter + Pika-projection tuning rather than an implicit
++            # full visual-backbone fine-tune.
++            nnx_utils.PathRegex("PaliGemma/img/.*"),
++        ),
++        data=LeRobotPikaBimanualDataConfig(
++            repo_id="pika/fold_cloth_0910_bimanual_fisheye",
++            # Reuse stats generated by prepare_pi05_pika_bimanual.sh for the
++            # full configuration; data semantics are identical.
++            assets=AssetsConfig(
++                assets_dir=os.path.join(
++                    os.environ.get("PIKA_OPENPI_ASSETS_BASE_DIR", "./assets"),
++                    "pi05_pika_bimanual_fisheye",
++                ),
++                asset_id="pika/fold_cloth_0910_bimanual_fisheye",
++            ),
++        ),
++        weight_loader=weight_loaders.PartialCheckpointWeightLoader(
++            "gs://openpi-assets/checkpoints/pi05_base/params"
++        ),
++        # EMA would update and retain a second copy of every frozen base weight
++        # on every step. It is prohibitively expensive for single-GPU LoRA and
++        # provides little value for this small, task-specific dataset.
++        ema_decay=None,
++        # Conservative starting point for one RTX 4090. The LoRA launcher
++        # defaults to this value but users may override BATCH_SIZE.
++        num_train_steps=30_000,
++        batch_size=4,
++        num_workers=4,
++        lr_schedule=_optimizer.CosineDecaySchedule(
++            warmup_steps=1_000,
++            peak_lr=5e-5,
++            decay_steps=30_000,
++            decay_lr=5e-6,
++        ),
++    ),
++    # Relative-pose Pika dual-arm configuration. The underlying LeRobot data
++    # deliberately remains lossless absolute pose data; the data transform
++    # converts it to a current-frame SE(3) representation before computing
++    # normalization statistics and before every training/inference call.
++    TrainConfig(
++        name="pi05_pika_bimanual_fisheye_relative",
++        model=pi0_config.Pi0Config(pi05=True, action_dim=14, action_horizon=16, max_token_len=256),
++        data=LeRobotPikaBimanualDataConfig(
++            repo_id="pika/fold_cloth_0910_bimanual_fisheye",
++            assets=AssetsConfig(asset_id="pika/fold_cloth_0910_bimanual_fisheye"),
++            relative_pose=True,
++        ),
++        weight_loader=weight_loaders.PartialCheckpointWeightLoader(
++            "gs://openpi-assets/checkpoints/pi05_base/params"
++        ),
++        assets_base_dir=os.environ.get("PIKA_OPENPI_ASSETS_BASE_DIR", "./assets"),
++        num_train_steps=30_000,
++        batch_size=64,
++        num_workers=4,
++        lr_schedule=_optimizer.CosineDecaySchedule(
++            warmup_steps=1_000,
++            peak_lr=5e-5,
++            decay_steps=30_000,
++            decay_lr=5e-6,
++        ),
++    ),
++    TrainConfig(
++        name="pi05_pika_bimanual_fisheye_relative_lora",
++        model=_PIKA_BIMANUAL_LORA_MODEL,
++        freeze_filter=nnx.Any(
++            _PIKA_BIMANUAL_LORA_MODEL.get_freeze_filter(),
++            nnx_utils.PathRegex("PaliGemma/img/.*"),
++        ),
++        data=LeRobotPikaBimanualDataConfig(
++            repo_id="pika/fold_cloth_0910_bimanual_fisheye",
++            assets=AssetsConfig(
++                assets_dir=os.path.join(
++                    os.environ.get("PIKA_OPENPI_ASSETS_BASE_DIR", "./assets"),
++                    "pi05_pika_bimanual_fisheye_relative",
++                ),
++                asset_id="pika/fold_cloth_0910_bimanual_fisheye",
++            ),
++            relative_pose=True,
++        ),
++        weight_loader=weight_loaders.PartialCheckpointWeightLoader(
++            "gs://openpi-assets/checkpoints/pi05_base/params"
++        ),
++        ema_decay=None,
++        num_train_steps=30_000,
++        batch_size=4,
++        num_workers=4,
++        lr_schedule=_optimizer.CosineDecaySchedule(
++            warmup_steps=1_000,
++            peak_lr=5e-5,
++            decay_steps=30_000,
++            decay_lr=5e-6,
++        ),
++    ),
+ ]
+ 
+ if len({config.name for config in _CONFIGS}) != len(_CONFIGS):
+diff --git a/policy/Pi_05/openpi/src/openpi/training/data_loader.py b/policy/Pi_05/openpi/src/openpi/training/data_loader.py
+index bf67dd1..e2563dc 100644
+--- a/policy/Pi_05/openpi/src/openpi/training/data_loader.py
++++ b/policy/Pi_05/openpi/src/openpi/training/data_loader.py
+@@ -143,9 +143,11 @@ def create_torch_dataset(
+     if repo_id == "fake":
+         return FakeDataset(model_config, num_samples=1024)
+ 
+-    dataset_meta = lerobot_dataset.LeRobotDatasetMetadata(repo_id)
++    dataset_meta = lerobot_dataset.LeRobotDatasetMetadata(repo_id, root=data_config.lerobot_root)
+     dataset = lerobot_dataset.LeRobotDataset(
+         data_config.repo_id,
++        root=data_config.lerobot_root,
++        episodes=list(data_config.episode_indices) if data_config.episode_indices is not None else None,
+         delta_timestamps={
+             key: [t / dataset_meta.fps for t in range(action_horizon)] for key in data_config.action_sequence_keys
+         },
+diff --git a/policy/Pi_05/openpi/src/openpi/transforms.py b/policy/Pi_05/openpi/src/openpi/transforms.py
+index b01e9db..71badd6 100644
+--- a/policy/Pi_05/openpi/src/openpi/transforms.py
++++ b/policy/Pi_05/openpi/src/openpi/transforms.py
+@@ -253,7 +253,12 @@ class TokenizePrompt(DataTransformFn):
+         if (prompt := data.pop("prompt", None)) is None:
+             raise ValueError("Prompt is required")
+ 
+-        is_batched_prompt = isinstance(prompt, (list, np.ndarray, jax.Array)) and not isinstance(prompt, str)
++        # InjectDefaultPrompt stores a single default string as a zero-dimensional
++        # ndarray. Treat that as a scalar prompt, not as a batch (``list`` on a
++        # 0-D array raises TypeError during policy inference).
++        is_batched_prompt = isinstance(prompt, list) or (
++            isinstance(prompt, (np.ndarray, jax.Array)) and np.ndim(prompt) > 0
++        )
+ 
+         if self.discrete_state_input:
+             if (state := data.get("state", None)) is None:

real_inference/verify_files.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""Check a transferred package against its SHA-256 manifest."""
+from pathlib import Path
+import hashlib
+import sys
+
+root=Path(__file__).resolve().parent
+failures=[];count=0
+for line in (root/'manifest.sha256').read_text().splitlines():
+    digest,sep,rel=line.partition('  ')
+    if not sep or len(digest)!=64:
+        raise ValueError(f'Invalid manifest line: {line!r}')
+    path=(root/rel).resolve()
+    if not path.is_relative_to(root) or not path.is_file():
+        failures.append((rel,'missing or invalid path'));continue
+    h=hashlib.sha256()
+    with path.open('rb') as f:
+        for chunk in iter(lambda:f.read(8*1024*1024),b''):h.update(chunk)
+    count+=1
+    if h.hexdigest()!=digest:failures.append((rel,'SHA-256 mismatch'))
+    if path.stat().st_size>100_000_000:print(f'checked {rel}',flush=True)
+if failures:
+    for rel,reason in failures:print(f'FAIL {rel}: {reason}',file=sys.stderr)
+    raise SystemExit(1)
+print(f'OK: {count} files match manifest.sha256')