dhb-xr 0.2.1__py3-none-any.whl

dhb_xr-0.2.1.dist-info/RECORD

@@ -0,0 +1,82 @@
+dhb_xr/__init__.py,sha256=OGQACX9IP1hbUMgUDIOEGBlEbRFXNd2nncxJL5qOhwk,1381
+dhb_xr/cli.py,sha256=BijyoMJN6K1VtbTAuDnMQa8_2x60zfRrJRmz-lYj6RY,7021
+dhb_xr/core/__init__.py,sha256=hJYdZzd9gz7O8K1FuE_qE981sr_-2q_gLDTRz9COv7E,593
+dhb_xr/core/geometry.py,sha256=UMkoS_zkKnPeT4KFJJwyNCxCESIXsFVFcmIF2Q_c2go,5090
+dhb_xr/core/geometry_torch.py,sha256=0dUt_00r6v1bPugd3943mEPNJyRh1oF4QhhUewwhpV0,2832
+dhb_xr/core/types.py,sha256=YdU6UpieQD0YjUKJox3cDLHxa7fHpBljO88c6fYd8rc,3671
+dhb_xr/database/__init__.py,sha256=32HgJVcHcoLVevq1RioM0BJUl-wNRLu9QCln0RHFh4k,315
+dhb_xr/database/motion_db.py,sha256=pnTrcXuswITtapUGKb2EWIaGfsd7c30mtlEEcVj2zv0,3099
+dhb_xr/database/retrieval.py,sha256=e4_pewBFtQGAhPeiOAZfoQjQWlrjoD13qzlw2Dt3pVg,279
+dhb_xr/database/similarity.py,sha256=rNtZEJJCAUuiX3rE_u-zEpW1gmDIa_Fwl68NoWMF9RM,2531
+dhb_xr/decoder/__init__.py,sha256=I9h9Nzzu6ZTrZlFHVzBb-okNEJueSk3R3SLAipCGTlw,262
+dhb_xr/decoder/decoder_torch.py,sha256=KVXgG3n9fDQeIsAqy_6R2V5lB6wrgG8OxLzeSo2C2lY,2133
+dhb_xr/decoder/dhb_dr.py,sha256=dmkxLzUM1YmbKFtoOZ7hsLG0YW_nFxAlF4XsyA7BwMQ,9375
+dhb_xr/decoder/dhb_qr.py,sha256=U-5YBFTGtUqpl3nVCf6pQIkQRf46sREknJ1mWZhb1WI,2969
+dhb_xr/encoder/__init__.py,sha256=j69h5aslEbpBoEiYv0oqKMhMox_2KoBpbMEIqr3Be9E,691
+dhb_xr/encoder/dhb_dr.py,sha256=ogLzF1Kx9-eFTtKSGoXgB65GQhMWRSpP4ql5KtANtRg,15448
+dhb_xr/encoder/dhb_qr.py,sha256=LnBczpW9nRyM5GgGUHfvcWYuB6h46o95tNXzXMK8yQI,4580
+dhb_xr/encoder/dhb_ti.py,sha256=P2QiZy2_7JWYEYDNpbGAzArnCZxDi_2iz2-8DtiWjrs,6611
+dhb_xr/encoder/encoder_torch.py,sha256=LM-B6gTAkxcyxZWThJ5EXamvuithnVd_mbKnqGxAIPo,1986
+dhb_xr/encoder/padding.py,sha256=vq9XtHBOayq94sTnc9BU4AR6wB0fGGivcRlPgu-g5iA,2741
+dhb_xr/generative/__init__.py,sha256=acS5iNWRcWmJ-AlWKu7P8qpoER5QXi3f4D6FLePtdic,2269
+dhb_xr/generative/flow_matching.py,sha256=tSryjgekkCGjTUgMHNd8Xw7oQIpHN6cypZ7OaR5VmAU,21442
+dhb_xr/generative/latent_encoder.py,sha256=oREET0kAyE4z38s0lkMRzlrVJKCi2g6B--peWPmr6BU,16123
+dhb_xr/generative/sampling.py,sha256=uIkOywq9_6m_YrKjhAQXv1SlvDzqHG5I3XdLs-dHlyw,5653
+dhb_xr/generative/training.py,sha256=bVT9DhQxEJ2cL0pkKtve3J3vmeBfaf1ZLv7U4Vjv6Eg,14559
+dhb_xr/generative/vfm_tokenizer.py,sha256=agH_0ok0EwR9b79Eo9651gtq4CKI6qzaF-VfsLGt3aU,15807
+dhb_xr/integration/__init__.py,sha256=1nscdikjCAKmO0NHKQ0heFGYHVDRE9pRRLDsM0khFxU,234
+dhb_xr/integration/vla/__init__.py,sha256=iw4SRn1Dbxjw5O5GgN71kRgMNbZnAh2-9SFJyjCqB48,291
+dhb_xr/integration/vla/libero.py,sha256=dYjl9GB4_0HneZXxW4NpvrvefUwQmFOXUh1jcT047-8,4398
+dhb_xr/integration/vla/pipeline.py,sha256=econak0wm-y8rrZvbRnwc9Ky7UFHYFIFho85EKdMx-E,2969
+dhb_xr/integration/vla/robocasa.py,sha256=TfN_G4PWR1rME67gvaPfvE6QnOnbe0RHmUkYkvUza9U,2561
+dhb_xr/losses/__init__.py,sha256=k0h45G3izn-mnLYG2gQaXnjULd3fBQasPP5pe3vdM4I,468
+dhb_xr/losses/geodesic_loss.py,sha256=vlSnXDWqC1QLFzCQjMEDapKXlTTkDq5N83qaYXBEaRA,3030
+dhb_xr/losses/hybrid_loss.py,sha256=sfMfSOEBUjWXRykD9XrJpLBf5wmf_VNwy_YZ06nST8w,1328
+dhb_xr/losses/invariant_loss.py,sha256=FHLzlDWPjqHAa92XEv0_DPJWx0VM3zXvTgkFGCWhx3w,2627
+dhb_xr/optimization/__init__.py,sha256=Ff5i4CpxtmaDl9TGdoByuBA4uWVfeIafOAYCfCqx4A4,2532
+dhb_xr/optimization/casadi_solver.py,sha256=BQtKG8bu2lVUQc7S9-8rwsNbZVF8cWg7OSRZKZyTm4Q,12966
+dhb_xr/optimization/constraints.py,sha256=MVrHJGHDT0D2aRfR1PmvCaEKxcvJxJZu8A_l1mr7ZwA,1046
+dhb_xr/optimization/cusadi_solver.py,sha256=MYwNhC91mT2r23jk8jJcdljz_UOLVyuEHyxuRF-tovM,11297
+dhb_xr/optimization/export_casadi_decode.py,sha256=sV3SjhRKaulIyCyqGCYeOGFYkrjKIPkNscZnmCxiZL4,3586
+dhb_xr/optimization/fatrop_solver.py,sha256=49LlbsXjVPUx4B6WPCb33rFxry3VQW7NioI-eK9cU5k,16861
+dhb_xr/optimization/torch_solver.py,sha256=YPnv3NR6zyC5eFim6-FUexHMR-1p3sFS0G1OCQRirbc,3536
+dhb_xr/preprocessing/__init__.py,sha256=nJars3sC7erIn4vbbQkZKm9OGOteyerbHzDnoA6Tb2Q,1263
+dhb_xr/preprocessing/diagnostics.py,sha256=ZNYdJjlcXHM1Gtm9MNoD922D5iEsUdHuAnKLaOO670Q,10986
+dhb_xr/preprocessing/trajectory_cleaner.py,sha256=CZASDH35e9WrLS8uaaRg3ZRwEXke-6nvUck13mj3iW4,17036
+dhb_xr/tokenization/__init__.py,sha256=YTr5Kg7mkkWbEBhVFXQErfKw-yGFv5A8Tb3tLpz9v54,1459
+dhb_xr/tokenization/causal_encoder.py,sha256=rWm4vryH9NpNks3omr7aRBPk9ByhumHABpoTf1pkIPM,1681
+dhb_xr/tokenization/compression.py,sha256=I-2QnB1bZpnvNucz6gWkFtuYhHS9uLudAOsbgoiZ_G0,25117
+dhb_xr/tokenization/hierarchical.py,sha256=B8I0dZFZApPvH1ouAlUXYRBclcUTaygQQJ_r0fffL5k,13323
+dhb_xr/tokenization/rvq.py,sha256=QMNqtjnKOF1oA10fD28rfODrOHoz_x9AUUPViuW7b8Q,5900
+dhb_xr/tokenization/vqvae.py,sha256=duxkeqtznH6At2i6Cly_0eH6Tezc9YGe9PzWThrJfrA,5021
+dhb_xr/utils/__init__.py,sha256=7y-Dqrb4yxxLsv2pUFKrayLtCdwpRVUCXi1oRE6SMuI,559
+dhb_xr/utils/io.py,sha256=MbEQEqnqdl6_DHA31Ey98Uc-2ZCeyUfO-oQqRVdhR8U,2195
+dhb_xr/utils/resampling.py,sha256=wlMt4rhqeeAH51uBxRYllpIZIE1xE0xSgFLB4OczyOU,2615
+dhb_xr/utils/xdof_loader.py,sha256=uSbW_-l9PofC6KKqELY5JlKwgTqqkN4jE5_0HkgEgIk,2887
+dhb_xr/visualization/__init__.py,sha256=ZnevC1zP2XqeTUXvH8zbbZdNs9YFQkCmlh3MjCao388,189
+dhb_xr/visualization/plot.py,sha256=kqg-rNSqHvrP5-jCFkAWxvshBsE1py3MDGgZKSkZXYg,8083
+examples/__init__.py,sha256=Lg0Tu6f20oyoCxWyl7MFDmgT6KYJL6Jd7zGG7SnRyJc,2077
+examples/basic_encoding.py,sha256=XHytFrSEBcznmDSQbW_U_70qp7zet2mIjUjd_-eOcKw,2591
+examples/benchmark_backends.py,sha256=6mvc0douictQ7zhaiQ5zHj9GvbhhSoDf4x0lgXELdcs,1233
+examples/dhb_qr_comparison.py,sha256=xPLfA0ysAoytJHqdxLZELYk2QlEEGpVOodRUDCJYawo,2697
+examples/dhb_ti_time_invariant.py,sha256=i0vz-pQTnddiQ-s0DpjpR8yT0i9Ic0aGRDmV8S2TrOc,2822
+examples/gpu_batch_optimization.py,sha256=jv-Am9p5q4StK8FOpCiAVBpOMxWGLsu7mT7mLkJI2RI,3119
+examples/imitation_learning.py,sha256=yWgZD0qIFJK2QMzMV_UWWnHi-S3EIaiNbvp1Qym3zkE,1879
+examples/motion_database.py,sha256=Wvtc2bowMkdrNJJrVt-ORYGBY03OdKgD54RDvYmQlco,2891
+examples/trajectory_adaptation.py,sha256=B6RRHHuc-JcOTQLZjv5U8UVwL4wVd6ZaZcga_P2rsec,2615
+examples/vla_tokenization.py,sha256=TWejgxv5c9X8IJwNK3GR_5fmiVyBqPI7qaeqaquAk74,3239
+examples/integration/__init__.py,sha256=SFF025lM9aV02z9QwKm4rrk6aUD0wy-9RjwRgQ8Gf0o,674
+examples/integration/libero_full_demo.py,sha256=tgmtXjbdR4U3GI4trBI62ar8HlGeWOxHBMIBCDdRuC4,24601
+examples/integration/libero_pro_dhb_demo.py,sha256=QT03UvkInuoPCtWM-9x7iF7R13JstiX1wfDQccBdi7U,44642
+examples/integration/libero_simulation_demo.py,sha256=mIQVU1EnwMcgVhR318gcNN306miBt_yBdaCg6tjBQwQ,8869
+examples/integration/libero_swap_demo.py,sha256=JqgnxGYLJ6LdQKb_1EQLvjQLf8-Wnpv6R-5MvDnechA,23422
+examples/integration/robocasa_libero_dhb_pipeline.py,sha256=WXR8LcPwMg_rrGxjLG0kjfpivH9RFiKCp7k1xZGKCf4,2103
+examples/integration/test_libero_adapter.py,sha256=JtY1__4cXNSiXf0e52J3_SAecBU2qGQvUiyrZ_GGVVk,1837
+examples/integration/test_libero_encoding.py,sha256=Zc7O5UGkTKyJSjzM-hrgGkt7Y8JQScwtqU1pg-Ak-4E,2654
+examples/integration/test_libero_retrieval.py,sha256=xYPpq6iLGTbO4VT6gWuV-q5eCG4tjaUtWtI4QFbMC-o,3264
+notebooks/__init__.py,sha256=1wsz8H_tTQauGz70WLbu0sabmVXSczWgIz48lZH97Sw,678
+dhb_xr-0.2.1.dist-info/METADATA,sha256=AJoBsoNzwCnnJ20SajWHqqnTzKj84b3zf_DgQTL7yz8,27562
+dhb_xr-0.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+dhb_xr-0.2.1.dist-info/entry_points.txt,sha256=o5_lMpoEN0MDfU478Wi7eJc3oDa9OedgalKQ438KLJM,60
+dhb_xr-0.2.1.dist-info/top_level.txt,sha256=dmAG5ym8zm7WzB1r3Gy9Sp9Tvux3k41TUEy-2P-VRXY,26
+dhb_xr-0.2.1.dist-info/RECORD,,

dhb_xr-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dhb_xr-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dhb_xr-examples = dhb_xr.cli:examples_cmd

dhb_xr-0.2.1.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+dhb_xr
+examples
+notebooks

examples/__init__.py

@@ -0,0 +1,54 @@
+"""
+DHB-XR Examples Package
+
+This package contains comprehensive examples demonstrating DHB-XR usage across
+various robotics and VLA applications, including both Python scripts and Jupyter notebooks.
+
+Quick Start Examples:
+- basic_encoding: Core DHB-DR/DHB-QR encoding and decoding
+- trajectory_adaptation: Retargeting trajectories to new poses
+- dhb_qr_comparison: Comparing DHB-DR vs DHB-QR representations
+- gpu_batch_optimization: Large-scale trajectory optimization
+- vla_tokenization: DHB-Token for discrete action sequences
+- motion_database: Similarity search and trajectory retrieval
+- imitation_learning: Invariant-based imitation learning losses
+- dhb_ti_time_invariant: Time-invariant reparameterization
+
+VLA Integration Examples:
+- libero_full_demo: Complete LIBERO simulation with DHB adaptation
+- libero_pro_dhb_demo: LIBERO-PRO perturbation robustness testing
+- libero_swap_demo: Spatial swap demonstration with naive vs DHB comparison
+- robocasa_libero_dhb_pipeline: RoboCASA and LIBERO data processing pipeline
+
+Tutorial Notebooks:
+- tutorial_dhb_basics.ipynb: Basic encoding/decoding concepts
+- tutorial_invariance_demo.ipynb: SE(3) invariance demonstration
+- tutorial_umi_xdof_motion_analysis.ipynb: Real-world UMI dataset analysis
+- demo_dhb_features_and_use_cases.ipynb: Comprehensive feature overview
+- tutorial_vla_integration.ipynb: VLA integration with LIBERO/RoboCASA
+
+Usage:
+    from dhb_xr_examples import *
+    # or import specific examples:
+    from dhb_xr_examples.basic_encoding import run_example
+
+    # Run notebooks with:
+    # jupyter notebook
+    # pixi run notebook
+"""
+
+__version__ = "0.2.0"
+
+# Convenience imports for common examples
+from .basic_encoding import run_example as run_basic_encoding
+from .trajectory_adaptation import run_example as run_trajectory_adaptation
+from .dhb_qr_comparison import run_example as run_dhb_comparison
+
+def __dir__():
+    """List all available examples."""
+    return [
+        'run_basic_encoding',
+        'run_trajectory_adaptation',
+        'run_dhb_comparison',
+        # Add more as needed
+    ]

examples/basic_encoding.py

@@ -0,0 +1,82 @@
+"""
+Basic DHB Encoding and Decoding Example
+
+This example demonstrates the core DHB-XR functionality: encoding SE(3) trajectories
+to invariant representations and decoding them back to poses.
+
+The example:
+1. Creates a synthetic trajectory (50 poses with random walk positions)
+2. Encodes to DHB-DR invariants using double-reflection method
+3. Decodes back to reconstruct the original trajectory
+4. Shows the shape preservation of the roundtrip encoding/decoding
+"""
+
+import numpy as np
+from dhb_xr import encode_dhb_dr, decode_dhb_dr
+from dhb_xr.core.types import DHBMethod, EncodingMethod
+
+
+def run_example():
+    """Run the basic encoding/decoding example."""
+    print("DHB-XR Basic Encoding Example")
+    print("=" * 40)
+
+    # Create synthetic trajectory
+    np.random.seed(42)
+    n = 50
+    positions = np.cumsum(np.random.randn(n, 3) * 0.01, axis=0)
+    quaternions = np.tile(np.array([1.0, 0.0, 0.0, 0.0]), (n, 1))
+
+    print(f"Original trajectory: {n} poses")
+    print(f"Positions shape: {positions.shape}")
+    print(f"Quaternions shape: {quaternions.shape}")
+
+    # Encode to DHB invariants
+    print("\nEncoding to DHB-DR invariants...")
+    out = encode_dhb_dr(
+        positions,
+        quaternions,
+        method=EncodingMethod.POSITION,
+        use_default_initial_frames=True,
+        dhb_method=DHBMethod.DOUBLE_REFLECTION,
+    )
+    print(f"Linear invariants shape: {out['linear_motion_invariants'].shape}")
+    print(f"Angular invariants shape: {out['angular_motion_invariants'].shape}")
+
+    # Decode back to poses
+    print("\nDecoding back to poses...")
+    decoded = decode_dhb_dr(
+        out["linear_motion_invariants"],
+        out["angular_motion_invariants"],
+        out["initial_pose"],
+        method=EncodingMethod.POSITION,
+        dhb_method=DHBMethod.DOUBLE_REFLECTION,
+        drop_padded=True,
+    )
+    print(f"Decoded positions shape: {decoded['positions'].shape}")
+    print(f"Decoded quaternions shape: {decoded['quaternions'].shape}")
+
+    # Check reconstruction quality
+    pos_error = np.mean(np.abs(positions - decoded["positions"]))
+    quat_error = np.mean(np.abs(quaternions - decoded["quaternions"]))
+
+    print("
+Reconstruction errors:")
+    print(".2e")
+    print(".2e")
+
+    if pos_error < 1e-10 and quat_error < 1e-10:
+        print("✅ Perfect reconstruction (errors within numerical precision)")
+    else:
+        print("⚠️  Reconstruction has some error - check parameters")
+
+    return out, decoded
+
+
+def main():
+    """Main function for command-line execution."""
+    run_example()
+
+
+if __name__ == "__main__":
+    main()

examples/benchmark_backends.py

@@ -0,0 +1,37 @@
+"""Benchmark encode/decode backends (numpy, optional torch/cpp)."""
+
+import time
+import numpy as np
+from dhb_xr import encode_dhb_dr, decode_dhb_dr
+from dhb_xr.core.types import DHBMethod, EncodingMethod
+
+def main():
+    n = 100
+    np.random.seed(0)
+    positions = np.cumsum(np.random.randn(n, 3) * 0.01, axis=0)
+    quaternions = np.tile(np.array([1.0, 0.0, 0.0, 0.0]), (n, 1))
+
+    # Encode
+    start = time.perf_counter()
+    for _ in range(50):
+        out = encode_dhb_dr(
+            positions, quaternions,
+            method=EncodingMethod.POSITION, use_default_initial_frames=True, dhb_method=DHBMethod.DOUBLE_REFLECTION,
+        )
+    elapsed = (time.perf_counter() - start) / 50
+    print(f"Encode (n={n}): {elapsed*1000:.2f} ms per call")
+
+    # Decode
+    start = time.perf_counter()
+    for _ in range(50):
+        decoded = decode_dhb_dr(
+            out["linear_motion_invariants"],
+            out["angular_motion_invariants"],
+            out["initial_pose"],
+            method=EncodingMethod.POSITION, dhb_method=DHBMethod.DOUBLE_REFLECTION, drop_padded=True,
+        )
+    elapsed = (time.perf_counter() - start) / 50
+    print(f"Decode: {elapsed*1000:.2f} ms per call")
+
+if __name__ == "__main__":
+    main()

examples/dhb_qr_comparison.py

@@ -0,0 +1,79 @@
+"""
+DHB-DR vs DHB-QR Comparison Example
+
+This example compares the two DHB invariant representations:
+
+DHB-DR (Double-Reflection with Euler angles):
+- 4 values per component: magnitude + 3 Euler angles
+- Compact representation, may have gimbal lock issues
+- Good for most applications
+
+DHB-QR (Double-Reflection with Quaternions):
+- 5 values per component: magnitude + unit quaternion (4 values)
+- More robust to singularities, smoother interpolation
+- Better for applications requiring quaternion-based losses
+
+Both provide SE(3)-invariant representations, but DHB-QR is preferred
+for applications involving quaternion operations or optimization.
+"""
+
+import numpy as np
+from dhb_xr.encoder.dhb_dr import encode_dhb_dr
+from dhb_xr.encoder.dhb_qr import encode_dhb_qr
+from dhb_xr.core.types import DHBMethod, EncodingMethod
+
+
+def run_example():
+    """Run the DHB-DR vs DHB-QR comparison example."""
+    print("DHB-DR vs DHB-QR Comparison")
+    print("=" * 40)
+
+    # Create synthetic trajectory
+    n = 40
+    np.random.seed(1)
+    positions = np.cumsum(np.random.randn(n, 3) * 0.01, axis=0)
+    quaternions = np.tile(np.array([1.0, 0.0, 0.0, 0.0]), (n, 1))
+
+    print(f"Trajectory: {n} poses")
+    print(f"Positions shape: {positions.shape}")
+    print(f"Quaternions shape: {quaternions.shape}")
+
+    # Encode with DHB-DR (Euler angles)
+    print("\nEncoding with DHB-DR (Euler angles)...")
+    out_dr = encode_dhb_dr(
+        positions,
+        quaternions,
+        method=EncodingMethod.POSITION,
+        use_default_initial_frames=True,
+        dhb_method=DHBMethod.DOUBLE_REFLECTION,
+    )
+    print(f"DHB-DR linear invariants shape: {out_dr['linear_motion_invariants'].shape}")
+    print(f"DHB-DR angular invariants shape: {out_dr['angular_motion_invariants'].shape}")
+
+    # Encode with DHB-QR (Quaternions)
+    print("\nEncoding with DHB-QR (Quaternions)...")
+    out_qr = encode_dhb_qr(
+        positions,
+        quaternions,
+        method=EncodingMethod.POSITION,
+        use_default_initial_frames=True,
+    )
+    print(f"DHB-QR linear invariants shape: {out_qr['linear_motion_invariants'].shape}")
+    print(f"DHB-QR angular invariants shape: {out_qr['angular_motion_invariants'].shape}")
+
+    # Compare dimensions
+    print("\nDimension comparison:")
+    print(f"DHB-DR: {out_dr['linear_motion_invariants'].shape[1]} values per linear component")
+    print(f"DHB-QR: {out_qr['linear_motion_invariants'].shape[1]} values per linear component")
+    print("\nDHB-DR uses Euler angles (3 values), DHB-QR uses quaternions (4 values)")
+
+    return out_dr, out_qr
+
+
+def main():
+    """Main function for command-line execution."""
+    run_example()
+
+
+if __name__ == "__main__":
+    main()

examples/dhb_ti_time_invariant.py

@@ -0,0 +1,72 @@
+"""
+DHB-TI: Time-invariant reparameterization.
+
+Reparameterize by geometric progress (translational arc-length, angular, or hybrid)
+and resample at uniform progress knots so invariants are approximately independent
+of execution speed and sampling rate. Then encode with DHB-DR or DHB-QR.
+"""
+
+import numpy as np
+from dhb_xr.encoder.dhb_ti import (
+    compute_progress,
+    resample_by_progress,
+    encode_dhb_dr_ti,
+    encode_dhb_qr_ti,
+)
+from dhb_xr.encoder.dhb_dr import encode_dhb_dr
+from dhb_xr.core.types import DHBMethod, EncodingMethod
+
+def main():
+    np.random.seed(42)
+    n = 50
+    positions = np.cumsum(np.random.randn(n, 3) * 0.01, axis=0)
+    quaternions = np.tile(np.array([1.0, 0.0, 0.0, 0.0]), (n, 1))
+
+    # Progress variables
+    progress_trans = compute_progress(positions, quaternions, kind="translation")
+    progress_angular = compute_progress(positions, quaternions, kind="angular")
+    progress_hybrid = compute_progress(positions, quaternions, kind="hybrid", alpha=0.5)
+    print("Progress (translation) total:", progress_trans[-1])
+    print("Progress (angular) total:", progress_angular[-1])
+    print("Progress (hybrid, α=0.5) total:", progress_hybrid[-1])
+
+    # Resample to M poses at uniform progress
+    M = 30
+    pos_m, quat_m = resample_by_progress(
+        positions, quaternions, M,
+        progress_kind="hybrid", alpha=0.5,
+    )
+    print("Resampled by progress: positions", pos_m.shape, "quaternions", quat_m.shape)
+
+    # Time-invariant encode (DHB-DR): same motion at different "speeds" gives similar invariants
+    out_ti = encode_dhb_dr_ti(
+        positions, quaternions, M,
+        progress_kind="hybrid", alpha=0.5,
+        method=EncodingMethod.POSITION, use_default_initial_frames=True,
+        dhb_method=DHBMethod.DOUBLE_REFLECTION,
+    )
+    print("DHB-TI (DR) linear invariants shape:", out_ti["linear_motion_invariants"].shape)
+
+    # Compare: raw encode vs TI encode (raw depends on sampling density)
+    out_raw = encode_dhb_dr(
+        positions, quaternions,
+        method=EncodingMethod.POSITION, use_default_initial_frames=True,
+        dhb_method=DHBMethod.DOUBLE_REFLECTION,
+    )
+    print("DHB-DR (raw) linear invariants shape:", out_raw["linear_motion_invariants"].shape)
+
+    # DHB-TI with DHB-QR
+    try:
+        out_ti_qr = encode_dhb_qr_ti(
+            positions, quaternions, M,
+            progress_kind="hybrid", alpha=0.5,
+            method=EncodingMethod.POSITION, use_default_initial_frames=True,
+        )
+        print("DHB-TI (QR) linear invariants shape:", out_ti_qr["linear_motion_invariants"].shape)
+    except ImportError:
+        print("DHB-QR not available; skip DHB-TI (QR).")
+
+    print("Done. Use progress_kind='translation'|'angular'|'hybrid' and alpha for rotation-dominant motions.")
+
+if __name__ == "__main__":
+    main()

examples/gpu_batch_optimization.py

@@ -0,0 +1,102 @@
+"""
+GPU Batched Trajectory Optimization Example
+
+This example demonstrates batched trajectory optimization for processing multiple
+trajectories simultaneously. Useful for:
+
+- Large-scale trajectory adaptation datasets
+- Real-time multi-trajectory optimization
+- GPU-accelerated batch processing
+
+The example:
+1. Creates a demo trajectory (30 poses)
+2. Defines two different start/goal pose pairs
+3. Uses BatchedTrajectoryOptimizer to adapt the trajectory for both pairs
+4. Shows the optimized results for both trajectories
+
+For GPU acceleration, set device="cuda" (requires PyTorch CUDA).
+"""
+
+import numpy as np
+from dhb_xr.optimization.torch_solver import BatchedTrajectoryOptimizer
+
+
+def run_example():
+    """Run the GPU batched trajectory optimization example."""
+    print("DHB-XR GPU Batched Trajectory Optimization")
+    print("=" * 45)
+
+    # Create demo trajectory
+    np.random.seed(1)
+    n = 30
+    demo_positions = np.cumsum(np.random.randn(n, 3) * 0.02, axis=0)
+    demo_quaternions = np.tile(np.array([1.0, 0.0, 0.0, 0.0]), (n, 1))
+
+    print(f"Demo trajectory: {n} poses")
+    print(f"Original start: {demo_positions[0]}")
+    print(f"Original goal:  {demo_positions[-1]}")
+
+    # Define two different start/goal pairs for batch optimization
+    init_poses = [
+        {
+            "position": demo_positions[0].copy(),
+            "quaternion": demo_quaternions[0].copy()
+        },
+        {
+            "position": demo_positions[0].copy() + np.array([0.05, 0, 0]),
+            "quaternion": demo_quaternions[0].copy()
+        },
+    ]
+    goal_poses = [
+        {
+            "position": demo_positions[-1].copy(),
+            "quaternion": demo_quaternions[-1].copy()
+        },
+        {
+            "position": demo_positions[-1].copy() + np.array([0.1, 0.05, 0]),
+            "quaternion": demo_quaternions[-1].copy()
+        },
+    ]
+
+    print("
+Batch optimization setup:")
+    print(f"Trajectory 0: {init_poses[0]['position']} → {goal_poses[0]['position']}")
+    print(f"Trajectory 1: {init_poses[1]['position']} → {goal_poses[1]['position']}")
+
+    # Run batched optimization
+    print("\nRunning batched optimization...")
+    optimizer = BatchedTrajectoryOptimizer(device="cpu", dhb_method="double_reflection")
+    adapted_pos, adapted_quat = optimizer.optimize(
+        demo_positions, demo_quaternions,
+        init_poses, goal_poses,
+        num_steps=20,
+        lr=1e-2,
+    )
+
+    print(f"✅ Optimization complete")
+    print(f"Adapted positions shape: {adapted_pos.shape}")
+    print(f"Adapted quaternions shape: {adapted_quat.shape}")
+
+    print("
+Results:")
+    for i in range(len(init_poses)):
+        start_pos = adapted_pos[i, 0]
+        goal_pos = adapted_pos[i, -1]
+        target_goal = goal_poses[i]['position']
+
+        goal_error = np.linalg.norm(goal_pos - target_goal)
+        print(f"Trajectory {i}:")
+        print(f"  Start: {start_pos}")
+        print(f"  Goal:  {goal_pos}")
+        print(".2e")
+
+    return adapted_pos, adapted_quat
+
+
+def main():
+    """Main function for command-line execution."""
+    run_example()
+
+
+if __name__ == "__main__":
+    main()

examples/imitation_learning.py

@@ -0,0 +1,53 @@
+"""Imitation learning: invariant-space and geodesic losses."""
+
+import numpy as np
+from dhb_xr.encoder.dhb_dr import encode_dhb_dr
+from dhb_xr.core.types import DHBMethod, EncodingMethod
+from dhb_xr.losses.invariant_loss import invariant_matching_loss
+from dhb_xr.losses.geodesic_loss import se3_geodesic_loss_np
+from dhb_xr.losses.hybrid_loss import hybrid_invariant_pose_loss
+
+def main():
+    np.random.seed(4)
+    n = 25
+    demo_pos = np.cumsum(np.random.randn(n, 3) * 0.02, axis=0)
+    demo_quat = np.tile(np.array([1.0, 0.0, 0.0, 0.0]), (n, 1))
+    pred_pos = demo_pos + np.random.randn(n, 3) * 0.005
+    pred_quat = demo_quat.copy()
+
+    out_demo = encode_dhb_dr(
+        demo_pos, demo_quat,
+        method=EncodingMethod.POSITION, use_default_initial_frames=True, dhb_method=DHBMethod.DOUBLE_REFLECTION,
+    )
+    out_pred = encode_dhb_dr(
+        pred_pos, pred_quat,
+        method=EncodingMethod.POSITION, use_default_initial_frames=True, dhb_method=DHBMethod.DOUBLE_REFLECTION,
+    )
+    U_demo = np.concatenate([
+        out_demo["linear_motion_invariants"],
+        out_demo["angular_motion_invariants"],
+    ], axis=1)
+    U_pred = np.concatenate([
+        out_pred["linear_motion_invariants"],
+        out_pred["angular_motion_invariants"],
+    ], axis=1)
+
+    loss_inv = invariant_matching_loss(U_pred, U_demo, method="dhb_dr")
+    print("Invariant matching loss (L2):", loss_inv)
+
+    loss_pose = se3_geodesic_loss_np(
+        pred_pos[-1], pred_quat[-1],
+        demo_pos[-1], demo_quat[-1],
+        beta=1.0,
+    )
+    print("SE(3) geodesic loss (final pose):", loss_pose)
+
+    loss_hybrid = hybrid_invariant_pose_loss(
+        pred_pos, pred_quat, demo_pos, demo_quat,
+        pred_invariants=U_pred, demo_invariants=U_demo,
+        alpha=0.5, beta=1.0,
+    )
+    print("Hybrid (invariant + pose) loss:", loss_hybrid)
+
+if __name__ == "__main__":
+    main()

examples/integration/__init__.py

@@ -0,0 +1,19 @@
+"""
+VLA Integration Examples
+
+Examples demonstrating DHB-XR integration with popular VLA benchmarks:
+
+LIBERO & LIBERO-PRO:
+- libero_full_demo: Complete simulation pipeline with trajectory adaptation
+- libero_pro_dhb_demo: Perturbation robustness analysis and simulation
+- libero_swap_demo: Spatial swap demonstration (naive vs DHB comparison)
+- libero_simulation_demo: Basic LIBERO integration
+
+Data Processing:
+- robocasa_libero_dhb_pipeline: End-to-end VLA data processing
+- test_libero_adapter: LIBERO HDF5 dataset loading
+- test_libero_encoding: DHB encoding on LIBERO trajectories
+- test_libero_retrieval: Motion retrieval across LIBERO tasks
+"""
+
+__version__ = "0.2.0"