Upload folder using huggingface_hub

README.md

@@ -79,6 +79,7 @@ print(f"Reconstructed shape: {reconstructed.shape}")  # [10, 50, 7]
 | vocab_size | Discrete vocabulary size (256 = 8-bit tokens) | 256 |
 | degree | B-spline polynomial degree (3=cubic, provides smooth trajectories) | 3 |
 | gripper_dof | Number of gripper DOFs, assumed to be at the end. Used for forced knot placement | 1 |
+| absolute_tol | Absolute tolerance for B-spline fitting error (e.g., 0.01 radians). Controls fitting accuracy and compression ratio. If set, overrides relative tolerance. | 0.01 |
 | do_pad | Whether to pad control points to fixed length | True |
 | device | Torch device ("cuda" or "cpu") | "cuda" |
 
@@ -90,6 +91,23 @@ The extra dimension is for time knots. For example, with default settings (50 ou
 
 **Key Difference from BEAST**: BEST uses adaptive compression where `out_seq_len` can vary based on trajectory complexity, while BEAST uses fixed `num_basis` control points.
 
+### Absolute Tolerance (absolute_tol)
+
+The `absolute_tol` parameter controls the fitting accuracy of the B-spline approximation:
+
+- **Definition**: Maximum allowed L∞ error between the B-spline reconstruction and the original trajectory
+- **Default**: 0.01 (appropriate for LIBERO tasks in radians)
+- **Effect on Compression**:
+  - Lower values (e.g., 0.001): Tighter fitting, more control points needed, larger token count
+  - Higher values (e.g., 0.1): Looser fitting, fewer control points, smaller token count
+- **Recommendation**:
+  - LIBERO manipulation: 0.01 (default)
+  - High-precision tasks: 0.001-0.005
+  - General arm motion: 0.01-0.05
+  - Speed-optimized: 0.05-0.1
+
+**Priority**: When both `absolute_tol` and `tol_ratio` are applicable, `absolute_tol` takes precedence for fitting error threshold.
+
 ## API Reference
 
 ### Encoding Methods

online_bspline_tokenizer.py

@@ -216,13 +216,15 @@ class BestBSpline:
         joint_dof: Number of joint DOFs
         gripper_dof: Number of gripper DOFs (从后往前数)
         check_step: Downsampling step for constraint checking acceleration
+        absolute_tol: Absolute tolerance for fitting error (default: 0.01)
         is_multi_process: Whether to use multiprocessing for batch compression (default: False)
     """
-    def __init__(self, degree: int = 3, joint_dof: int = 6, gripper_dof: int = 1, check_step=1, use_gurobi: bool = False, is_multi_process: bool = False):
+    def __init__(self, degree: int = 3, joint_dof: int = 6, gripper_dof: int = 1, check_step=1, absolute_tol: float = 0.01, use_gurobi: bool = False, is_multi_process: bool = False):
         self.degree = degree
         self.joint_dof = joint_dof
         self.gripper_dof = gripper_dof
         self.check_step = check_step   # 降采样步长，用于加速
+        self.absolute_tol = absolute_tol  # 绝对容差
         self.use_gurobi = use_gurobi
         self.is_multi_process = is_multi_process
 
@@ -240,17 +242,15 @@ class BestBSpline:
         return forced_knot_times
 
     def fit(self, trajectory: torch.Tensor, cpu_cores: int = min(mp.cpu_count(), 16),
-            tol_ratio: float = 0.03, absolute_tol: Optional[float] = 0.01, 
-            time_limit: int = 10, max_length: Optional[int] = None) -> Tuple[List[int], List[List[float]]]:
+            tol_ratio: float = 0.03, time_limit: int = 10, max_length: Optional[int] = None) -> Tuple[List[int], List[List[float]]]:
         """
-        Note: libero上设置为 absolute_tol, 0.01 为tokenization 误差。
-        Fit B-spline to trajectory using least squares.
+        Fit B-spline to trajectory using least squares with MILP optimization.
+        Uses self.absolute_tol for fitting error tolerance.
         
         Args:
             trajectory: Input trajectory [seq_len, num_dof]
             cpu_cores: Number of CPU cores for parallel MILP solving
             tol_ratio: Tolerance ratio for relative fitting error (eps = d_range × tol_ratio)
-            absolute_tol: Absolute tolerance for fitting error. If set, overrides tol_ratio
             time_limit: Time limit for MILP solver in seconds
             max_length: Optional maximum length for the B-spline representation
         Returns:
@@ -335,8 +335,8 @@ class BestBSpline:
         # 拟合误差约束
         for d in range(self.joint_dof):
             # 使用绝对误差或相对误差
-            if absolute_tol is not None:
-                eps = float(absolute_tol)
+            if self.absolute_tol is not None:
+                eps = float(self.absolute_tol)
             else:
                 d_range = float(np.max(joint_traj[:, d]) - np.min(joint_traj[:, d]))
                 if d_range < 1e-6: d_range = 1.0
@@ -519,11 +519,13 @@ class BestTokenizer(torch.nn.Module, ProcessorMixin):
 
     def __init__(self, num_dof: int = 7, in_seq_len: int = 10, out_seq_len: int = 5,
                  vocab_size: int = 256, degree: int = 3, gripper_dof: int = 1, 
-                 do_pad: bool = True, use_gurobi: bool = False, is_multi_process: bool = False, device: str = "cuda"):
+                 absolute_tol: float = 0.01, do_pad: bool = True, use_gurobi: bool = False, 
+                 is_multi_process: bool = False, device: str = "cuda"):
         super().__init__()
         self.in_seq_len = in_seq_len
         self.out_seq_len = out_seq_len 
         self.vocab_size = vocab_size
+        self.absolute_tol = absolute_tol
         # DOF distribution
         self.gripper_dof = gripper_dof # 0 means 没有 gripper
         self.joint_dof = num_dof - self.gripper_dof
@@ -535,6 +537,7 @@ class BestTokenizer(torch.nn.Module, ProcessorMixin):
             degree=degree,
             joint_dof=self.joint_dof,
             gripper_dof=self.gripper_dof,
+            absolute_tol=absolute_tol,
             use_gurobi=use_gurobi,
             is_multi_process=is_multi_process,
         )

processor_config.json

@@ -9,6 +9,7 @@
   "vocab_size": 256,
   "degree": 3,
   "gripper_dof": 1,
+  "absolute_tol": 0.01,
   "do_pad": true,
   "use_gurobi": false,
   "is_multi_process": false,