Add files using upload-large-folder tool

DragMesh/dragmesh/data/balanced_dataset_utils.py

@@ -0,0 +1,193 @@
+"""
+File: utils/balanced_dataset_utils.py
+Utilities for building/reading LMDB datasets and computing balanced sampling weights.
+"""
+import os
+import torch
+import numpy as np
+import lmdb
+import pickle
+import gc
+import random
+import multiprocessing as mp
+from typing import Optional, List, Dict, Tuple
+from torch.utils.data import Dataset, Subset
+from tqdm import tqdm
+
+def random_axis_rotation(data: Dict[str, np.ndarray]) -> Dict[str, np.ndarray]:
+    """Random in-plane rotation augmentation."""
+    angle = random.uniform(0, 2 * np.pi)
+    cos_a, sin_a = np.cos(angle), np.sin(angle)
+    R = np.array([[cos_a, -sin_a, 0], [sin_a, cos_a, 0], [0, 0, 1]], dtype=np.float32)
+    
+    keys_to_rotate = ['initial_mesh', 'drag_point', 'drag_vector', 'joint_axis', 
+                      'joint_origin', 'rotation_direction', 'trajectory_vectors', 'drag_trajectory']
+    for k in keys_to_rotate:
+        if k in data:
+            val = data[k]
+            if isinstance(val, np.ndarray) and val.shape[-1] == 3:
+                data[k] = val @ R.T
+    return data
+
+def get_motion_type_weights(dataset: Dataset, target_ratio: float = 3.0) -> torch.Tensor:
+    """Compute class-balancing weights for WeightedRandomSampler."""
+    indices = dataset.indices if isinstance(dataset, Subset) else range(len(dataset))
+    base_dataset = dataset.dataset if isinstance(dataset, Subset) else dataset
+    
+    revolute_indices = []
+    prismatic_indices = []
+
+    print("Analyzing dataset motion types...")
+    for idx_in_subset, i in enumerate(tqdm(indices)):
+        try:
+            sample = base_dataset[i]
+            if sample is None: continue
+            jt = sample['joint_type'].item() if hasattr(sample['joint_type'], 'item') else sample['joint_type']
+            if jt == 0: revolute_indices.append(idx_in_subset)
+            elif jt == 1: prismatic_indices.append(idx_in_subset)
+        except: continue
+
+    weights = torch.ones(len(dataset), dtype=torch.double)
+    if not revolute_indices or not prismatic_indices:
+        return weights
+
+    n_rev, n_pri = len(revolute_indices), len(prismatic_indices)
+    if n_rev / n_pri > target_ratio:
+        w_rev, w_pri = (n_pri * target_ratio) / n_rev, 1.0
+    else:
+        w_rev, w_pri = 1.0, (n_rev / target_ratio) / n_pri
+    
+    weights[revolute_indices] = w_rev
+    weights[prismatic_indices] = w_pri
+    return weights
+
+# --- Worker helpers (used by optional multiprocessing / sequential fallback) ---
+def _worker_init(ds):
+    global _global_dataset
+    _global_dataset = ds
+
+def _worker_process_sample(idx):
+    """Worker-side sample serialization."""
+    try:
+        sample = _global_dataset[idx]
+        if sample is None:
+            return None
+        
+        serialized = {}
+        keys_to_save = [
+            'initial_mesh', 'drag_point', 'drag_vector', 'qr_gt', 'qd_gt', 
+            'joint_type', 'joint_axis', 'joint_origin', 'part_mask',
+            'norm_center', 'norm_scale', 'origin_normalization_version',
+            'rotation_direction', 'trajectory_vectors', 'drag_trajectory'
+        ]
+        for k in keys_to_save:
+            if k in sample:
+                val = sample[k]
+                if isinstance(val, torch.Tensor):
+                    serialized[k] = val.numpy()
+                else:
+                    serialized[k] = val
+        return serialized
+    except Exception:
+        return None
+
+def build_vae_lmdb(dataset, output_path, categories=None, num_frames=16, num_points=4096):
+    """
+    Build an LMDB for VAE training.
+
+    Notes:
+    - In some environments (especially after torch/OMP initialization), multiprocessing with the
+      default fork start method may deadlock (symptoms: progress bar stuck; processes in futex_wait).
+      Since the loader already supports low-memory streaming point sampling, the default here is a
+      sequential build for stability.
+    - Fixes the "'int' object has no attribute 'size'" error when parsing joint_type.
+    """
+    print("\n" + "="*70)
+    print("BUILDING VAE LMDB DATABASE")
+    print("="*70)
+    
+    total_samples = len(dataset)
+    # Open LMDB environment (100GB map size by default).
+    env = lmdb.open(output_path, map_size=1024**3 * 100) 
+    
+    actual_count = 0
+    revolute_count = 0
+    prismatic_count = 0
+
+    # Default: sequential execution to avoid mp/fork deadlocks.
+    global _global_dataset
+    _global_dataset = dataset
+    pbar = tqdm(range(total_samples), total=total_samples, desc="Writing LMDB")
+    for idx in pbar:
+        serialized = _worker_process_sample(idx)
+        if serialized is None:
+            continue
+
+        # --- Robust joint_type parsing ---
+        jt_val = serialized.get('joint_type')
+        if jt_val is not None:
+            # Handle numpy arrays
+            if isinstance(jt_val, np.ndarray):
+                jt = int(jt_val.item()) if jt_val.size == 1 else int(jt_val[0])
+            # Handle python scalars / sequences (int, float, list, ...)
+            else:
+                jt = int(jt_val[0]) if isinstance(jt_val, (list, tuple)) else int(jt_val)
+            
+            if jt == 0: revolute_count += 1
+            else: prismatic_count += 1
+
+        # Write LMDB entry.
+        with env.begin(write=True) as txn:
+            key = f"{actual_count:08d}".encode('ascii')
+            txn.put(key, pickle.dumps(serialized))
+            actual_count += 1
+        
+        del serialized
+        if actual_count % 100 == 0:
+            gc.collect()
+
+    # Write metadata.
+    with env.begin(write=True) as txn:
+        metadata = {
+            'num_samples': actual_count, 'num_frames': num_frames, 'num_points': num_points,
+            'categories': categories, 'revolute_count': revolute_count, 'prismatic_count': prismatic_count
+        }
+        txn.put(b'__metadata__', pickle.dumps(metadata))
+
+    env.close()
+    print(f"\nDone! Saved {actual_count} samples.")
+
+class VAE_LMDBDataset(Dataset):
+    def __init__(self, lmdb_path: str, augment: bool = False):
+        self.env = lmdb.open(lmdb_path, readonly=True, lock=False, readahead=False, meminit=False)
+        self.augment = augment
+        with self.env.begin(write=False) as txn:
+            meta = txn.get(b'__metadata__')
+            if meta is None: raise ValueError("Corrupt LMDB!")
+            self.metadata = pickle.loads(meta)
+        self.num_samples = self.metadata['num_samples']
+
+    def __len__(self): return self.num_samples
+            
+    def __getitem__(self, idx: int):
+        key = f"{idx:08d}".encode('ascii')
+        with self.env.begin(write=False) as txn:
+            data = txn.get(key)
+        if not data: return None
+        
+        np_data = pickle.loads(data)
+        
+        if self.augment and random.random() < 0.5:
+            np_data = random_axis_rotation(np_data)
+        
+        res = {}
+        for k, v in np_data.items():
+            if isinstance(v, np.ndarray):
+                if v.dtype == np.float64: v = v.astype(np.float32)
+                res[k] = torch.from_numpy(v)
+            else:
+                res[k] = torch.tensor(v)
+        
+        if 'joint_type' in res: res['joint_type'] = res['joint_type'].long()
+        res['is_cross_category'] = torch.tensor(0).long()
+        return res

DragMesh/dragmesh/data/data_loader_v2.py

@@ -0,0 +1,939 @@
+import os
+import numpy as np
+import trimesh
+import xml.etree.ElementTree as ET
+from typing import Dict, List, Tuple, Optional
+from collections import deque
+import gc
+import torch
+import torch.nn.functional as F
+
+from dragmesh.utils.kpp_normalization import mesh_center_scale, normalize_points, normalize_vector
+
+
+
+def axis_angle_to_dualquat(axis: np.ndarray, origin: np.ndarray, angle: float) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Convert axis-angle representation to dual quaternion for revolute joint.
+    """
+    # Normalize axis
+    axis = axis / (np.linalg.norm(axis) + 1e-8)
+
+    # Rotation quaternion from axis-angle
+    half_angle = angle / 2.0
+    sin_half = np.sin(half_angle)
+    cos_half = np.cos(half_angle)
+
+    qr = np.array([cos_half, axis[0] * sin_half, axis[1] * sin_half, axis[2] * sin_half])
+
+    # Translation quaternion
+    t_vec = origin - quaternion_rotate(qr, origin)
+    t = np.array([0.0, t_vec[0], t_vec[1], t_vec[2]])
+
+    qd = 0.5 * quaternion_multiply(t, qr)
+
+    return qr, qd
+
+
+def translation_to_dualquat(axis: np.ndarray, distance: float) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Convert translation to dual quaternion for prismatic joint.
+    """
+    # Normalize axis
+    axis = axis / (np.linalg.norm(axis) + 1e-8)
+
+    # No rotation for prismatic joint
+    qr = np.array([1.0, 0.0, 0.0, 0.0])
+
+    # Translation vector
+    t_vec = axis * distance
+    t = np.array([0.0, t_vec[0], t_vec[1], t_vec[2]])
+
+    # qd = 0.5 * quaternion_mul(t, qr) = 0.5 * t (since qr is identity)
+    qd = 0.5 * t
+
+    return qr, qd
+
+
+def quaternion_multiply(q1: np.ndarray, q2: np.ndarray) -> np.ndarray:
+    """Multiply two quaternions."""
+    w1, x1, y1, z1 = q1
+    w2, x2, y2, z2 = q2
+
+    w = w1*w2 - x1*x2 - y1*y2 - z1*z2
+    x = w1*x2 + x1*w2 + y1*z2 - z1*y2
+    y = w1*y2 - x1*z2 + y1*w2 + z1*x2
+    z = w1*z2 + x1*y2 - y1*x2 + z1*w2
+
+    return np.array([w, x, y, z])
+
+
+def quaternion_conjugate(q: np.ndarray) -> np.ndarray:
+    """Compute quaternion conjugate."""
+    return np.array([q[0], -q[1], -q[2], -q[3]])
+
+
+def quaternion_rotate(q: np.ndarray, point: np.ndarray) -> np.ndarray:
+    """Apply quaternion rotation to a 3D point."""
+    p = np.array([0.0, point[0], point[1], point[2]])
+    q_conj = quaternion_conjugate(q)
+    rotated = quaternion_multiply(quaternion_multiply(q, p), q_conj)
+    return rotated[1:]
+
+
+
+class GAPartNetLoaderV2:
+    """
+    Data loader for GAPartNet with Dual Quaternion ground truth.
+    """
+
+    def __init__(self, dataset_root: str):
+        self.dataset_root = dataset_root
+        self.object_list = self._get_object_list()
+
+    def _get_object_list(self) -> List[str]:
+        """Get list of all object directories in the dataset."""
+        object_list = []
+        # Support the case where dataset_root directly points to an object folder.
+        if os.path.exists(os.path.join(self.dataset_root, "mobility_annotation_gapartnet.urdf")):
+            return [self.dataset_root]
+
+        for category in os.listdir(self.dataset_root):
+            category_path = os.path.join(self.dataset_root, category)
+            if not os.path.isdir(category_path):
+                continue
+            
+            # Support the case where the category directory itself contains the URDF.
+            if os.path.exists(os.path.join(category_path, "mobility_annotation_gapartnet.urdf")):
+                object_list.append(category_path)
+                continue
+
+            for obj_id in os.listdir(category_path):
+                obj_path = os.path.join(category_path, obj_id)
+                urdf_path = os.path.join(obj_path, "mobility_annotation_gapartnet.urdf")
+                if os.path.exists(urdf_path):
+                    object_list.append(obj_path)
+        return object_list
+
+    def parse_urdf(self, urdf_path: str) -> Dict:
+        """Parse URDF file to extract joint information."""
+        tree = ET.parse(urdf_path)
+        root = tree.getroot()
+
+        joints = []
+        links = {}
+
+        # Parse links and extract ALL mesh filenames
+        for link in root.findall('link'):
+            link_name = link.get('name')
+            # Keep the link entry even if it has no mesh: it can still be a joint attachment.
+            mesh_files = []
+            for visual in link.findall('visual'):
+                geometry = visual.find('geometry')
+                if geometry is not None:
+                    mesh = geometry.find('mesh')
+                    if mesh is not None:
+                        mesh_filename = mesh.get('filename')
+                        if mesh_filename not in mesh_files:  # Avoid duplicates
+                            mesh_files.append(mesh_filename)
+            links[link_name] = mesh_files
+
+        # Parse joints (only movable joints are added to the `joints` list).
+        for joint in root.findall('joint'):
+            joint_type = joint.get('type')
+            if joint_type == 'fixed':
+                continue
+
+            joint_name = joint.get('name')
+            parent = joint.find('parent').get('link')
+            child = joint.find('child').get('link')
+
+            axis_elem = joint.find('axis')
+            if axis_elem is not None:
+                axis = [float(x) for x in axis_elem.get('xyz').split()]
+            else:
+                axis = [0, 0, 1]
+
+            origin_elem = joint.find('origin')
+            if origin_elem is not None:
+                xyz_str = origin_elem.get('xyz')
+                rpy_str = origin_elem.get('rpy')
+                xyz = [float(x) for x in xyz_str.split()] if xyz_str else [0, 0, 0]
+                rpy = [float(x) for x in rpy_str.split()] if rpy_str else [0, 0, 0]
+            else:
+                xyz = [0, 0, 0]
+                rpy = [0, 0, 0]
+
+            limit_elem = joint.find('limit')
+            if limit_elem is not None:
+                lower = float(limit_elem.get('lower'))
+                upper = float(limit_elem.get('upper'))
+            else:
+                lower = -1.57
+                upper = 1.57
+
+            joints.append({
+                'name': joint_name,
+                'type': joint_type,
+                'parent': parent,
+                'child': child,
+                'axis': np.array(axis),
+                'origin_xyz': np.array(xyz),
+                'origin_rpy': np.array(rpy),
+                'limit': {'lower': lower, 'upper': upper}
+            })
+
+        # --- Build a full tree map (including fixed joints) ---
+        # This is important for propagating motion to descendant links (e.g., handle follows door).
+        full_tree_map = {}
+        for joint in root.findall('joint'):
+            p = joint.find('parent').get('link')
+            c = joint.find('child').get('link')
+            if p not in full_tree_map:
+                full_tree_map[p] = []
+            full_tree_map[p].append(c)
+
+        return {'joints': joints, 'links': links, 'full_tree_map': full_tree_map}
+
+    def _get_subtree_links(self, root_link: str, tree_map: Dict[str, List[str]]) -> List[str]:
+        """
+        Collect all descendant links starting from `root_link` (including itself).
+        """
+        subtree: List[str] = []
+        seen = set()
+        queue = deque([root_link])
+        while queue:
+            current = queue.popleft()
+            if current in seen:
+                continue
+            seen.add(current)
+            subtree.append(current)
+            for child in tree_map.get(current, []):
+                queue.append(child)
+        return subtree
+
+    def _joint_motion_span(self, joint: Dict) -> float:
+        """Estimate motion span to pick a representative joint (avoid tiny first-part joints)."""
+        jtype = joint.get('type')
+        if jtype == 'continuous':
+            return float(2.0 * np.pi)
+        lower = float(joint.get('limit', {}).get('lower', -1.57))
+        upper = float(joint.get('limit', {}).get('upper', 1.57))
+        span = abs(upper - lower)
+        # Some joints have near-zero ranges (e.g., buttons with 0.005). Avoid degeneracy.
+        if not np.isfinite(span) or span < 1e-6:
+            return float(np.pi / 6.0) if jtype in ['revolute'] else 0.01
+        return float(span)
+
+    def _select_joint_and_moving_links(
+        self,
+        urdf_data: Dict,
+        part_meshes: Optional[Dict[str, trimesh.Trimesh]] = None,
+        links: Optional[Dict[str, List[str]]] = None,
+        obj_path: Optional[str] = None,
+        joint_selection: str = "largest_motion",
+        joint_idx: Optional[int] = None,
+    ) -> Tuple[Dict, List[str]]:
+        """
+        Select a joint for sample generation and return the corresponding moving-subtree links.
+
+        - joint_selection:
+          - "first": the first movable joint
+          - "random": a random movable joint
+          - "largest_motion": maximize (motion span) × (moving geometry scale). Recommended default to
+            avoid selecting tiny parts such as small buttons.
+        """
+        joints: List[Dict] = urdf_data.get('joints', [])
+        if not joints:
+            raise ValueError("No movable joints found")
+
+        if joint_idx is not None:
+            if joint_idx < 0 or joint_idx >= len(joints):
+                raise IndexError(f"joint_idx {joint_idx} out of range (0..{len(joints)-1})")
+            joint = joints[joint_idx]
+            moving_links = self._get_subtree_links(joint['child'], urdf_data['full_tree_map'])
+            return joint, moving_links
+
+        if joint_selection == "first":
+            joint = joints[0]
+            moving_links = self._get_subtree_links(joint['child'], urdf_data['full_tree_map'])
+            return joint, moving_links
+
+        if joint_selection == "random":
+            joint = joints[int(np.random.randint(0, len(joints)))]
+            moving_links = self._get_subtree_links(joint['child'], urdf_data['full_tree_map'])
+            return joint, moving_links
+
+        # Default: "largest_motion"
+        best_joint = None
+        best_links: List[str] = []
+        best_score = -1.0
+        for j in joints:
+            subtree_links = self._get_subtree_links(j['child'], urdf_data['full_tree_map'])
+            # Estimate moving geometry scale (prefer vertex count; otherwise use mesh-file count as a proxy).
+            geom_score = 0
+            if part_meshes is not None:
+                for ln in subtree_links:
+                    mesh = part_meshes.get(ln)
+                    if mesh is not None:
+                        geom_score += int(len(mesh.vertices))
+            else:
+                links_dict = links
+                if links_dict is None or obj_path is None:
+                    geom_score = 0
+                else:
+                    for ln in subtree_links:
+                        for fn in (links_dict.get(ln) or []):
+                            if os.path.exists(os.path.join(obj_path, fn)):
+                                geom_score += 1
+
+            if geom_score <= 0:
+                continue
+
+            score = float(geom_score) * self._joint_motion_span(j)
+            if score > best_score:
+                best_score = score
+                best_joint = j
+                best_links = subtree_links
+
+        if best_joint is None:
+            # Fallback to "first".
+            joint = joints[0]
+            moving_links = self._get_subtree_links(joint['child'], urdf_data['full_tree_map'])
+            return joint, moving_links
+
+        return best_joint, best_links
+
+    def load_part_meshes(self, obj_path: str, links: Dict[str, List[str]]) -> Dict[str, trimesh.Trimesh]:
+        """
+        Load meshes for each part/link.
+        """
+        part_meshes = {}
+
+        for link_name, mesh_filenames in links.items():
+            link_meshes = []
+            for mesh_filename in mesh_filenames:
+                mesh_path = os.path.join(obj_path, mesh_filename)
+                if os.path.exists(mesh_path):
+                    try:
+                        mesh = trimesh.load(mesh_path, force='mesh', process=False)
+                        link_meshes.append(mesh)
+                    except Exception as e:
+                        # print(f"Warning: Failed to load {mesh_path}: {e}")
+                        pass
+
+            if len(link_meshes) > 0:
+                if len(link_meshes) == 1:
+                    part_meshes[link_name] = link_meshes[0]
+                else:
+                    combined_mesh = trimesh.util.concatenate(link_meshes)
+                    part_meshes[link_name] = combined_mesh
+
+        return part_meshes
+
+    def _load_mesh_safe(self, mesh_path: str) -> Optional[trimesh.Trimesh]:
+        """
+        More robust mesh loading:
+        - Accept trimesh.Scene outputs
+        - Keep process=False to avoid unnecessary recomputation
+        """
+        if not os.path.exists(mesh_path):
+            return None
+        try:
+            m = trimesh.load(mesh_path, force='mesh', process=False)
+        except Exception:
+            return None
+
+        if isinstance(m, trimesh.Scene):
+            geoms = [g for g in m.geometry.values() if isinstance(g, trimesh.Trimesh)]
+            if not geoms:
+                return None
+            try:
+                m = trimesh.util.concatenate(geoms)
+            except Exception:
+                return None
+
+        if not isinstance(m, trimesh.Trimesh):
+            return None
+        if m.vertices is None or m.faces is None:
+            return None
+        if len(m.vertices) == 0 or len(m.faces) == 0:
+            return None
+        return m
+
+    def _stream_sample_points(
+        self,
+        obj_path: str,
+        links: Dict[str, List[str]],
+        moving_links: set,
+        num_points: int,
+        joint_origin: np.ndarray,
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Low-memory mode: avoid mesh concatenation.
+        Load each mesh file -> sample points -> release immediately.
+
+        Returns:
+          - points: [num_points, 3] float32
+          - point_mask: [num_points] int32 (0=static, 1=movable)
+          - movable_points: [K, 3] float32 (only for drag-point sampling; K<=num_points)
+          - bounds_min: [3] float32
+          - bounds_max: [3] float32
+        """
+        # Count available mesh files to allocate per-mesh sampling budget.
+        mesh_entries: List[Tuple[str, int]] = []  # (mesh_path, is_moving)
+        for link_name, mesh_filenames in links.items():
+            is_moving = 1 if link_name in moving_links else 0
+            for mesh_filename in mesh_filenames:
+                mesh_path = os.path.join(obj_path, mesh_filename)
+                if os.path.exists(mesh_path):
+                    mesh_entries.append((mesh_path, is_moving))
+
+        if not mesh_entries:
+            raise ValueError(f"No meshes found under {obj_path}")
+
+        n_total = len(mesh_entries)
+        base = max(1, int(num_points // n_total))
+        rem = int(num_points - base * n_total)
+        if rem < 0:
+            rem = 0
+
+        all_points = []
+        all_masks = []
+        movable_points = []
+
+        bounds_min = np.array([np.inf, np.inf, np.inf], dtype=np.float32)
+        bounds_max = np.array([-np.inf, -np.inf, -np.inf], dtype=np.float32)
+
+        # Sample points per mesh.
+        for i, (mesh_path, is_moving) in enumerate(mesh_entries):
+            n_i = base + (1 if i < rem else 0)
+            if n_i <= 0:
+                continue
+
+            mesh = self._load_mesh_safe(mesh_path)
+            if mesh is None:
+                continue
+
+            # Accumulate bounds.
+            try:
+                b = mesh.bounds.astype(np.float32)
+                bounds_min = np.minimum(bounds_min, b[0])
+                bounds_max = np.maximum(bounds_max, b[1])
+            except Exception:
+                pass
+
+            try:
+                pts, _ = trimesh.sample.sample_surface(mesh, n_i)
+            except Exception:
+                del mesh
+                continue
+
+            pts = pts.astype(np.float32, copy=False)
+            mask = np.full((len(pts),), int(is_moving), dtype=np.int32)
+
+            all_points.append(pts)
+            all_masks.append(mask)
+            if is_moving:
+                movable_points.append(pts)
+
+            # Proactively release large objects to reduce peak memory.
+            del mesh
+            if (i % 10) == 0:
+                gc.collect()
+
+        if not all_points:
+            raise ValueError(f"Failed to sample any points from {obj_path}")
+
+        points = np.concatenate(all_points, axis=0)
+        point_mask = np.concatenate(all_masks, axis=0)
+
+        # Trim/pad to exactly num_points (meshes may fail to load, causing mismatch).
+        if len(points) >= num_points:
+            points = points[:num_points]
+            point_mask = point_mask[:num_points]
+        else:
+            # If insufficient, pad by resampling with replacement (avoid downstream failures).
+            pad_n = num_points - len(points)
+            rep_idx = np.random.randint(0, len(points), size=pad_n)
+            points = np.concatenate([points, points[rep_idx]], axis=0)
+            point_mask = np.concatenate([point_mask, point_mask[rep_idx]], axis=0)
+
+        if movable_points:
+            movable_points = np.concatenate(movable_points, axis=0)
+        else:
+            movable_points = points[point_mask.astype(bool)]
+
+        if movable_points is None or len(movable_points) == 0:
+            raise ValueError("No movable points sampled (moving subtree has no geometry?)")
+
+        # If bounds were not updated (extreme edge cases), fall back to point-cloud bounds.
+        if not np.isfinite(bounds_min).all() or not np.isfinite(bounds_max).all():
+            bounds_min = points.min(axis=0).astype(np.float32)
+            bounds_max = points.max(axis=0).astype(np.float32)
+
+        return points, point_mask, movable_points, bounds_min, bounds_max
+
+    def generate_training_sample(
+        self,
+        obj_idx: int,
+        num_frames: int = 16,
+        joint_selection: str = "largest_motion",
+        joint_idx: Optional[int] = None,
+        return_mesh: bool = True,
+        num_points: Optional[int] = None,
+    ) -> Dict:
+        """
+        Generate training sample with dual quaternion ground truth.
+        Fix motion leakage by recursively collecting all descendant moving parts.
+        """
+        obj_path = self.object_list[obj_idx]
+
+        # Parse URDF
+        urdf_path = os.path.join(obj_path, "mobility_annotation_gapartnet.urdf")
+        urdf_data = self.parse_urdf(urdf_path)
+
+        if len(urdf_data['joints']) == 0:
+            raise ValueError(f"No movable joints found in {obj_path}")
+
+        # Select a joint for sample generation (default avoids always picking a tiny first joint).
+        # When return_mesh=False, avoid loading full meshes (OOM); use mesh-file count as a proxy score.
+        part_meshes = None
+        if return_mesh:
+            part_meshes = self.load_part_meshes(obj_path, urdf_data['links'])
+
+        joint, moving_links_list = self._select_joint_and_moving_links(
+            urdf_data=urdf_data,
+            part_meshes=part_meshes,
+            links=urdf_data.get('links'),
+            obj_path=obj_path,
+            joint_selection=joint_selection,
+            joint_idx=joint_idx,
+        )
+        
+        # --- Core: descendant propagation ---
+        moving_root_link = joint['child']
+        
+        # Use the full tree map to collect all links that should move with this joint
+        # (e.g., door -> handle, lock). `moving_root_link` may have many descendants via fixed joints.
+        all_moving_links = set(moving_links_list if moving_links_list else self._get_subtree_links(moving_root_link, urdf_data['full_tree_map']))
+
+        # ========== Low-memory point-cloud mode (for LMDB building) ==========
+        if not return_mesh:
+            if num_points is None:
+                raise ValueError("return_mesh=False requires num_points")
+
+            points, point_mask, movable_points, bounds_min, bounds_max = self._stream_sample_points(
+                obj_path=obj_path,
+                links=urdf_data['links'],
+                moving_links=all_moving_links,
+                num_points=int(num_points),
+                joint_origin=joint['origin_xyz'],
+            )
+
+            # Sample a drag point: pick a movable point far from the joint origin.
+            if joint['type'] in ['revolute', 'continuous']:
+                d = np.linalg.norm(movable_points - joint['origin_xyz'][None, :], axis=1)
+                if len(d) == 0:
+                    raise ValueError("No movable points for drag sampling")
+                k = max(1, len(d) // 5)  # top 20%
+                far_idx = np.argpartition(d, -k)[-k:]
+                drag_point_start = movable_points[np.random.choice(far_idx)].copy()
+
+                lower, upper = joint['limit']['lower'], joint['limit']['upper']
+                if upper - lower < np.pi:
+                    lower, upper = -np.pi, np.pi
+                angle_change = upper - lower
+                rotation_direction = np.array(joint['axis']) * np.sign(angle_change)
+            else:
+                drag_point_start = movable_points[np.random.randint(0, len(movable_points))].copy()
+                rotation_direction = None
+
+            # Subsequent steps (DQ sequence / trajectory generation) follow the original logic.
+            lower, upper = joint['limit']['lower'], joint['limit']['upper']
+
+            if joint['type'] == 'continuous':
+                upper = max(upper, np.pi)
+                lower = min(lower, -np.pi)
+
+            if upper <= lower:
+                upper = lower + 1.0
+
+            if upper > lower:
+                angles = np.linspace(lower, upper, num_frames)
+            else:
+                if joint['type'] == 'continuous':
+                    angles = np.linspace(-np.pi, np.pi, num_frames)
+                else:
+                    angles = np.linspace(0, np.pi/2, num_frames)
+
+            qr_sequence = []
+            qd_sequence = []
+            for angle in angles:
+                if joint['type'] == 'revolute' or joint['type'] == 'continuous':
+                    qr, qd = axis_angle_to_dualquat(joint['axis'], joint['origin_xyz'], angle)
+                elif joint['type'] == 'prismatic':
+                    qr, qd = translation_to_dualquat(joint['axis'], angle)
+                else:
+                    raise ValueError(f"Unknown joint type: {joint['type']}")
+                qr_sequence.append(qr)
+                qd_sequence.append(qd)
+
+            qr_sequence = np.array(qr_sequence)
+            qd_sequence = np.array(qd_sequence)
+
+            drag_trajectory = []
+            for qr, qd in zip(qr_sequence, qd_sequence):
+                point_rotated = quaternion_rotate(qr, drag_point_start)
+                t_vec = 2.0 * quaternion_multiply(qd, quaternion_conjugate(qr))[1:]
+                drag_trajectory.append(point_rotated + t_vec)
+            drag_trajectory = np.array(drag_trajectory)
+
+            if len(drag_trajectory) > 2:
+                start_tangent = drag_trajectory[1] - drag_trajectory[0]
+                mid_idx = len(drag_trajectory) // 2
+                mid_tangent = drag_trajectory[mid_idx+1] - drag_trajectory[mid_idx]
+                end_tangent = drag_trajectory[-1] - drag_trajectory[-2]
+                trajectory_vectors = np.stack([start_tangent, mid_tangent, end_tangent])
+            else:
+                diff = drag_trajectory[-1] - drag_trajectory[0]
+                trajectory_vectors = np.stack([diff, diff, diff])
+
+            diffs = drag_trajectory[1:] - drag_trajectory[:-1]
+            lengths = np.linalg.norm(diffs, axis=1)
+            total_length = lengths.sum()
+            if total_length > 0:
+                avg_dir = np.mean(trajectory_vectors, axis=0)
+                avg_dir = avg_dir / (np.linalg.norm(avg_dir) + 1e-8)
+                drag_vector = avg_dir * total_length
+            else:
+                drag_vector = drag_trajectory[-1] - drag_trajectory[0]
+
+            rotation_direction = None
+            if joint['type'] in ['revolute', 'continuous']:
+                if len(angles) >= 2:
+                    angle_change = angles[-1] - angles[0]
+                    rotation_direction = np.array(joint['axis']) * np.sign(angle_change)
+                else:
+                    rotation_direction = np.array(joint['axis'])
+
+            drag_dir = drag_vector / (np.linalg.norm(drag_vector) + 1e-8)
+            relative_point = drag_point_start - joint['origin_xyz']
+            cross_axis_drag = np.cross(joint['axis'], drag_dir)
+            rotation_sign = np.sign(np.dot(cross_axis_drag, relative_point)) or 1.0
+
+            if rotation_direction is None:
+                rotation_direction = np.array(joint['axis'])
+
+            rotation_direction = rotation_direction * rotation_sign
+            drag_vector = drag_vector * rotation_sign
+
+            return {
+                # Use ndarray instead of trimesh so upstream datasets can normalize/write LMDB directly.
+                'initial_mesh': points.astype(np.float32, copy=False),
+                'drag_point': drag_point_start.astype(np.float32, copy=False),
+                'drag_vector': drag_vector.astype(np.float32, copy=False),
+                'trajectory_vectors': trajectory_vectors.astype(np.float32, copy=False),
+                'rotation_direction': rotation_direction.astype(np.float32, copy=False),
+                'qr_sequence': qr_sequence.astype(np.float32, copy=False),
+                'qd_sequence': qd_sequence.astype(np.float32, copy=False),
+                'drag_trajectory': drag_trajectory.astype(np.float32, copy=False),
+                'joint_type': joint['type'],
+                # point-level mask (0=static, 1=movable)
+                'part_mask': point_mask.astype(np.int32, copy=False),
+                'obj_path': obj_path,
+                'joint_axis': joint['axis'],
+                'joint_origin': joint['origin_xyz'],
+                # Optionally return bounds for upstream normalization.
+                'bounds_min': bounds_min,
+                'bounds_max': bounds_max,
+            }
+
+        # ========== Full mesh concatenation mode (for inference / visualization) ==========
+        if part_meshes is None:
+            part_meshes = self.load_part_meshes(obj_path, urdf_data['links'])
+        # Gather moving meshes and static meshes.
+        movable_meshes_list = []
+        static_meshes_list = []
+
+        for link_name, mesh in part_meshes.items():
+            if link_name in all_moving_links:
+                movable_meshes_list.append(mesh)
+            else:
+                static_meshes_list.append(mesh)
+
+        if not movable_meshes_list:
+            raise ValueError(f"Child link {moving_root_link} (and descendants) have no meshes")
+
+        # Concatenate all moving parts.
+        child_mesh = trimesh.util.concatenate(movable_meshes_list)
+
+        # Sample a drag point.
+        if joint['type'] in ['revolute', 'continuous']:
+            # Sample the farthest point over the whole moving part.
+            distances = np.linalg.norm(child_mesh.vertices - joint['origin_xyz'], axis=1)
+            far_indices = np.argsort(distances)[-max(1, len(child_mesh.vertices) // 5):]  # Top 20%
+            drag_point_idx = np.random.choice(far_indices)
+            drag_point_start = child_mesh.vertices[drag_point_idx].copy()
+
+            # Improve angle range
+            lower, upper = joint['limit']['lower'], joint['limit']['upper']
+            if upper - lower < np.pi:
+                lower, upper = -np.pi, np.pi
+            
+            # For rotation_direction
+            angle_change = upper - lower
+            rotation_direction = np.array(joint['axis']) * np.sign(angle_change)
+
+        else:
+            drag_point_idx = np.random.randint(0, len(child_mesh.vertices))
+            drag_point_start = child_mesh.vertices[drag_point_idx].copy()
+
+        # Generate dual quaternion sequence
+        lower, upper = joint['limit']['lower'], joint['limit']['upper']
+
+        if joint['type'] == 'continuous':
+            upper = max(upper, np.pi)  
+            lower = min(lower, -np.pi)
+        
+        # Protect against weird limits
+        if upper <= lower:
+             upper = lower + 1.0
+
+        if upper > lower:
+            angles = np.linspace(lower, upper, num_frames)
+        else:
+            if joint['type'] == 'continuous':
+                angles = np.linspace(-np.pi, np.pi, num_frames)
+            else:
+                angles = np.linspace(0, np.pi/2, num_frames)  
+
+        qr_sequence = []
+        qd_sequence = []
+
+        for angle in angles:
+            if joint['type'] == 'revolute' or joint['type'] == 'continuous':
+                qr, qd = axis_angle_to_dualquat(
+                    joint['axis'],
+                    joint['origin_xyz'],
+                    angle
+                )
+            elif joint['type'] == 'prismatic':
+                qr, qd = translation_to_dualquat(joint['axis'], angle)
+            else:
+                raise ValueError(f"Unknown joint type: {joint['type']}")
+
+            qr_sequence.append(qr)
+            qd_sequence.append(qd)
+
+        qr_sequence = np.array(qr_sequence)  # [num_frames, 4]
+        qd_sequence = np.array(qd_sequence)  # [num_frames, 4]
+
+        # Combine all parts into initial mesh (Static + Combined Movable)
+        if static_meshes_list:
+            static_mesh_combined = trimesh.util.concatenate(static_meshes_list)
+            initial_mesh = trimesh.util.concatenate([static_mesh_combined, child_mesh])
+            
+            # Create part mask (0=static, 1=movable)
+            num_static_verts = len(static_mesh_combined.vertices)
+            num_movable_verts = len(child_mesh.vertices)
+            part_mask = np.concatenate([
+                np.zeros(num_static_verts, dtype=np.int32),
+                np.ones(num_movable_verts, dtype=np.int32)
+            ])
+        else:
+            # Only the moving part is present.
+            initial_mesh = child_mesh
+            part_mask = np.ones(len(child_mesh.vertices), dtype=np.int32)
+
+        # Calculate drag vector with trajectory information
+        drag_trajectory = []
+        for qr, qd in zip(qr_sequence, qd_sequence):
+            point_rotated = quaternion_rotate(qr, drag_point_start)
+            t_vec = 2.0 * quaternion_multiply(qd, quaternion_conjugate(qr))[1:]
+            point_transformed = point_rotated + t_vec
+            drag_trajectory.append(point_transformed)
+
+        drag_trajectory = np.array(drag_trajectory)  # [num_frames, 3]
+
+        # Multi-tangent
+        if len(drag_trajectory) > 2:
+            start_tangent = drag_trajectory[1] - drag_trajectory[0]
+            mid_idx = len(drag_trajectory) // 2
+            mid_tangent = drag_trajectory[mid_idx+1] - drag_trajectory[mid_idx]
+            end_tangent = drag_trajectory[-1] - drag_trajectory[-2]
+            trajectory_vectors = np.stack([start_tangent, mid_tangent, end_tangent])
+        else:
+            # Fallback for very short trajectories
+            diff = drag_trajectory[-1] - drag_trajectory[0]
+            trajectory_vectors = np.stack([diff, diff, diff]) # Simple broadcast
+
+        # Improved drag_vector
+        diffs = drag_trajectory[1:] - drag_trajectory[:-1]
+        lengths = np.linalg.norm(diffs, axis=1)
+        total_length = lengths.sum()
+        if total_length > 0:
+            avg_dir = np.mean(trajectory_vectors, axis=0)
+            avg_dir = avg_dir / (np.linalg.norm(avg_dir) + 1e-8)
+            drag_vector = avg_dir * total_length
+        else:
+            drag_vector = drag_trajectory[-1] - drag_trajectory[0]
+
+        # Rotation Direction & Sign Fix
+        rotation_direction = None
+        if joint['type'] in ['revolute', 'continuous']:
+            if len(angles) >= 2:
+                angle_change = angles[-1] - angles[0]
+                rotation_direction = np.array(joint['axis']) * np.sign(angle_change)
+            else:
+                rotation_direction = np.array(joint['axis']) 
+
+        drag_dir = drag_vector / (np.linalg.norm(drag_vector) + 1e-8)
+        relative_point = drag_point_start - joint['origin_xyz']
+        cross_axis_drag = np.cross(joint['axis'], drag_dir)
+        rotation_sign = np.sign(np.dot(cross_axis_drag, relative_point)) or 1.0
+
+        if rotation_direction is None:
+             rotation_direction = np.array(joint['axis'])
+
+        rotation_direction = rotation_direction * rotation_sign
+        drag_vector = drag_vector * rotation_sign
+
+        return {
+            'initial_mesh': initial_mesh,
+            'drag_point': drag_point_start,
+            'drag_vector': drag_vector,
+            'trajectory_vectors': trajectory_vectors,  
+            'rotation_direction': rotation_direction,  
+            'qr_sequence': qr_sequence,
+            'qd_sequence': qd_sequence,
+            'drag_trajectory': drag_trajectory,  # extra field for LMDB checks
+            'joint_type': joint['type'],
+            'part_mask': part_mask,
+            'obj_path': obj_path,
+            'joint_axis': joint['axis'],  
+            'joint_origin': joint['origin_xyz']  
+        }
+
+    def __len__(self):
+        return len(self.object_list)
+
+
+# ==============================================================================
+#  DragMeshDatasetV2 (PyTorch Dataset)
+# ==============================================================================
+
+class DragMeshDatasetV2(torch.utils.data.Dataset):
+    """
+    PyTorch Dataset with Dual Quaternion ground truth.
+    """
+
+    def __init__(self, dataset_root: str, num_frames: int = 16, num_points: int = 4096, joint_selection: str = "largest_motion"):
+        self.loader = GAPartNetLoaderV2(dataset_root)
+        self.num_frames = num_frames
+        self.num_points = num_points
+        self.joint_selection = joint_selection
+
+    def mesh_to_pointcloud(self, mesh: trimesh.Trimesh, num_points: int) -> np.ndarray:
+        """Sample point cloud from mesh surface."""
+        points, face_idx = trimesh.sample.sample_surface(mesh, num_points)
+        return points
+
+    def normalize_mesh(self, mesh: trimesh.Trimesh) -> Tuple[trimesh.Trimesh, np.ndarray, float]:
+        """
+        Normalize mesh to unit bounding box centered at origin.
+        """
+        bounds = mesh.bounds
+        center = (bounds[0] + bounds[1]) / 2
+        scale = (bounds[1] - bounds[0]).max()
+        
+        if scale < 1e-6:
+            scale = 1.0
+
+        mesh_normalized = mesh.copy()
+        mesh_normalized.vertices = (mesh_normalized.vertices - center) / scale
+        return mesh_normalized, center, scale
+
+    def __len__(self):
+        return len(self.loader)
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        """
+        Get a training sample.
+        """
+        sample = self.loader.generate_training_sample(idx, self.num_frames, joint_selection=self.joint_selection)
+
+        # Use an inference-reproducible frame for KPP origin labels.  The
+        # previous joint-origin-centered frame made the origin target always 0.
+        center, scale = mesh_center_scale(sample['initial_mesh'])
+
+        mesh_normalized_verts = normalize_points(sample['initial_mesh'].vertices, center, scale)
+        mesh_normalized = trimesh.Trimesh(vertices=mesh_normalized_verts, 
+                                          faces=sample['initial_mesh'].faces)
+        
+        initial_pc, face_idx = trimesh.sample.sample_surface(mesh_normalized, self.num_points)
+
+        drag_point = normalize_points(sample['drag_point'], center, scale)
+        drag_vector = normalize_vector(sample['drag_vector'], scale)
+
+        rotation_direction = sample.get('rotation_direction')
+        if rotation_direction is not None:
+            rotation_direction = np.array(rotation_direction)  
+
+        trajectory_vectors = sample.get('trajectory_vectors')
+        if trajectory_vectors is not None:
+            trajectory_vectors = np.array(trajectory_vectors)  
+        
+        joint_origin_normalized = normalize_points(sample['joint_origin'], center, scale)
+
+        if sample['joint_type'] == 'revolute' or sample['joint_type'] == 'continuous':
+            joint_type = 0
+        elif sample['joint_type'] == 'prismatic':
+            joint_type = 1
+        else:
+            joint_type = 0  # default to revolute
+        
+        qr_gt = sample['qr_sequence']
+        
+        qd_gt = sample['qd_sequence'].copy()
+        qd_gt = qd_gt / scale
+        
+        joint_axis = sample['joint_axis']
+        joint_axis = joint_axis / (np.linalg.norm(joint_axis) + 1e-8)
+        
+        original_mesh = sample['initial_mesh']
+        vertex_part_mask = sample['part_mask'] # [N_verts]
+        
+        sampled_part_mask = np.zeros(self.num_points, dtype=np.int32)
+        for i, fid in enumerate(face_idx):
+            face_vertices = original_mesh.faces[fid]
+            face_mask_values = vertex_part_mask[face_vertices]
+            sampled_part_mask[i] = np.bincount(face_mask_values.astype(int)).argmax()
+    
+        result = {
+            'initial_mesh': torch.from_numpy(initial_pc).float(),
+            'drag_point': torch.from_numpy(drag_point).float(),
+            'drag_vector': torch.from_numpy(drag_vector).float(),
+            'qr_gt': torch.from_numpy(qr_gt).float(),
+            'qd_gt': torch.from_numpy(qd_gt).float(),
+            'joint_type': torch.tensor(joint_type).long(),
+            'joint_axis': torch.from_numpy(joint_axis).float(),
+            'joint_origin': torch.from_numpy(joint_origin_normalized).float(),
+            'part_mask': torch.from_numpy(sampled_part_mask).float(),
+            'norm_center': torch.from_numpy(center).float(),
+            'norm_scale': torch.tensor(scale).float(),
+            'origin_normalization_version': torch.tensor(1).long(),
+        }
+
+        if rotation_direction is not None:
+            result['rotation_direction'] = torch.from_numpy(rotation_direction).float()
+
+        if trajectory_vectors is not None:
+            result['trajectory_vectors'] = torch.from_numpy(trajectory_vectors).float()
+            
+        # Propagate drag_trajectory if needed.
+        if 'drag_trajectory' in sample:
+            traj = (sample['drag_trajectory'] - center) / scale
+            result['drag_trajectory'] = torch.from_numpy(traj).float()
+
+        return result

DragMesh/dragmesh/data/dataset_utils.py

@@ -0,0 +1,189 @@
+"""
+Shared dataset utilities for category-based data loading.
+"""
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+import json
+import torch
+import numpy as np
+from typing import Optional, List, Dict
+
+from dragmesh.data.data_loader_v2 import GAPartNetLoaderV2, DragMeshDatasetV2
+from dragmesh.utils.kpp_normalization import mesh_center_scale, normalize_points, normalize_vector
+import trimesh
+
+
+class FixedGAPartNetLoader(GAPartNetLoaderV2):
+    """Fixed loader for flat directory structure with category filtering."""
+
+    def __init__(self, dataset_root: str, categories: Optional[List[str]] = None):
+        self.categories = categories
+        super().__init__(dataset_root)
+
+    def _get_object_list(self):
+        """Get list of all object directories in the dataset (flat structure)."""
+        object_list = []
+        for obj_id in os.listdir(self.dataset_root):
+            obj_path = os.path.join(self.dataset_root, obj_id)
+            if not os.path.isdir(obj_path):
+                continue
+            urdf_path = os.path.join(obj_path, "mobility_annotation_gapartnet.urdf")
+            if not os.path.exists(urdf_path):
+                continue
+
+            # Check category filtering
+            if self.categories is not None:
+                meta_path = os.path.join(obj_path, "meta.json")
+                if os.path.exists(meta_path):
+                    try:
+                        with open(meta_path, 'r') as f:
+                            meta = json.load(f)
+                            category = meta.get('model_cat', None)
+                            if category not in self.categories:
+                                continue
+                    except:
+                        continue
+                else:
+                    continue
+
+            object_list.append(obj_path)
+        return object_list
+
+
+class FixedDragMeshDatasetV2(DragMeshDatasetV2):
+    """Dataset wrapper with category filtering."""
+
+    def __init__(self, dataset_root: str, num_frames: int = 16, num_points: int = 4096,
+                 categories: Optional[List[str]] = None,
+                 joint_selection: str = "largest_motion"):
+        self.loader = FixedGAPartNetLoader(dataset_root, categories=categories)
+        self.num_frames = num_frames
+        self.num_points = num_points
+        self.joint_selection = joint_selection
+
+
+class KPPDataset(FixedDragMeshDatasetV2):
+    """Dataset for KPP-Net training with part_mask and joint parameters."""
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        """
+        Get a training sample.
+        """
+        sample = self.loader.generate_training_sample(idx, self.num_frames, joint_selection=getattr(self, "joint_selection", "largest_motion"))
+
+        # KPP origin prediction must use an inference-reproducible frame.
+        # Centering at the GT joint origin makes the training label always zero.
+        center, scale = mesh_center_scale(sample['initial_mesh'])
+
+        mesh_normalized_verts = normalize_points(sample['initial_mesh'].vertices, center, scale)
+        mesh_normalized = trimesh.Trimesh(vertices=mesh_normalized_verts, 
+                                          faces=sample['initial_mesh'].faces)
+        
+        initial_pc, face_idx = trimesh.sample.sample_surface(mesh_normalized, self.num_points)
+
+        drag_point = normalize_points(sample['drag_point'], center, scale)
+        drag_vector = normalize_vector(sample['drag_vector'], scale)
+        
+        joint_origin_normalized = normalize_points(sample['joint_origin'], center, scale)
+
+        
+        #  Joint type
+        if sample['joint_type'] == 'revolute' or sample['joint_type'] == 'continuous':
+            joint_type = 0
+        elif sample['joint_type'] == 'prismatic':
+            joint_type = 1
+        else:
+            joint_type = 0  # default to revolute
+        
+        qr_gt = sample['qr_sequence']
+
+        if joint_type == 0:
+            qd_gt = sample['qd_sequence'].copy() 
+            qd_gt = qd_gt / scale
+        else:
+            qd_gt = sample['qd_sequence'].copy()
+            qd_gt = qd_gt / scale
+
+        # 8) Joint axis (unchanged; normalized).
+        joint_axis = sample['joint_axis']
+        joint_axis = joint_axis / (np.linalg.norm(joint_axis) + 1e-8)
+        
+        # 9) Part mask (unchanged).
+        original_mesh = sample['initial_mesh']
+        vertex_part_mask = sample['part_mask'] # [N_verts]
+        
+        sampled_part_mask = np.zeros(self.num_points, dtype=np.int32)
+        for i, fid in enumerate(face_idx):
+            face_vertices = original_mesh.faces[fid]
+            face_mask_values = vertex_part_mask[face_vertices]
+            sampled_part_mask[i] = np.bincount(face_mask_values.astype(int)).argmax()
+    
+
+        return {
+            'initial_mesh': torch.from_numpy(initial_pc).float(),
+            'drag_point': torch.from_numpy(drag_point).float(),
+            'drag_vector': torch.from_numpy(drag_vector).float(),
+            'qr_gt': torch.from_numpy(qr_gt).float(),
+            'qd_gt': torch.from_numpy(qd_gt).float(),
+            'joint_type': torch.tensor(joint_type).long(),
+            'joint_axis': torch.from_numpy(joint_axis).float(),
+            'joint_origin': torch.from_numpy(joint_origin_normalized).float(),
+            'part_mask': torch.from_numpy(sampled_part_mask).float(),
+            'norm_center': torch.from_numpy(center).float(),
+            'norm_scale': torch.tensor(scale).float(),
+            'origin_normalization_version': torch.tensor(1).long(),
+        }
+
+    def mesh_to_pointcloud_with_faces(self, mesh, num_points):
+        """Sample point cloud from mesh surface and return face indices."""
+        import trimesh
+        points, face_idx = trimesh.sample.sample_surface(mesh, num_points)
+        return points, face_idx
+
+    def map_face_mask_to_points(self, mesh, part_mask_vertices, face_indices):
+        """Map vertex-based part mask to sampled points using face indices."""
+        # For each sampled point (via face), get the mask value
+        part_mask_points = np.zeros(len(face_indices), dtype=np.float32)
+
+        for i, face_idx in enumerate(face_indices):
+            # Get vertices of this face
+            face_vertices = mesh.faces[face_idx]
+            # Use majority vote or first vertex mask value
+            face_mask_values = part_mask_vertices[face_vertices]
+            part_mask_points[i] = np.mean(face_mask_values)  # Average mask value for this face
+
+        return part_mask_points
+
+
+def load_category_config(config_path: str):
+    """
+    Load category split configuration from JSON file.
+
+    Args:
+        config_path: Path to category_split.json
+
+    Returns:
+        tuple of (train_categories, val_categories)
+    """
+    if not os.path.exists(config_path):
+        raise FileNotFoundError(f"Category config not found: {config_path}")
+
+    with open(config_path, 'r') as f:
+        category_config = json.load(f)
+
+    train_categories = category_config['train_categories']
+    val_categories = category_config['val_categories']
+
+    return train_categories, val_categories
+
+
+def print_category_split_info(config_path: str, train_categories: List[str], val_categories: List[str]):
+    """Print information about category split."""
+    print("\n" + "="*60)
+    print("CATEGORY-BASED DATA SPLIT")
+    print("="*60)
+    print(f"Config loaded from: {config_path}")
+    print(f"Training categories ({len(train_categories)}): {train_categories}")
+    print(f"Validation categories ({len(val_categories)}): {val_categories}")
+    print("="*60 + "\n")

DragMesh/dragmesh/geometry/deformation.py

@@ -0,0 +1,317 @@
+"""
+Mesh Deformation Module using ArtGS's Dual Quaternion
+
+This module applies predicted dual quaternion transformations to mesh vertices
+to generate animated mesh sequences.
+"""
+
+import torch
+import torch.nn.functional as F
+import numpy as np
+import trimesh
+from typing import Tuple, List, Dict
+from dragmesh.geometry.dual_quaternion import (
+    dual_quaternion_apply,
+    dual_quaternion_to_quaternion_translation,
+    quaternion_translation_apply
+)
+
+
+class MeshDeformationEngine:
+    """
+    Apply dual quaternion transformations to mesh vertices.
+    Uses ArtGS's dual_quaternion_apply for smooth articulated motion.
+    """
+
+    def __init__(self, device='cpu'):
+        self.device = device
+
+    def apply_dualquat_to_vertices(
+        self,
+        vertices: torch.Tensor,
+        qr: torch.Tensor,
+        qd: torch.Tensor,
+        part_mask: torch.Tensor = None
+    ) -> torch.Tensor:
+        """
+        Apply dual quaternion transformation to vertices.
+
+        Args:
+            vertices: Vertex positions [N, 3] or [B, N, 3]
+            qr: Rotation quaternion [4] or [B, 4]
+            qd: Translation quaternion [4] or [B, 4]
+            part_mask: Which vertices to transform [N] (0=static, 1=movable)
+                      If None, transform all vertices
+
+        Returns:
+            Transformed vertices [N, 3] or [B, N, 3]
+        """
+        # Handle batched vs single input
+        is_batched = vertices.dim() == 3
+
+        if part_mask is None:
+            # Transform all vertices
+            deformed_vertices = dual_quaternion_apply((qr, qd), vertices)
+        else:
+            # Only transform movable vertices
+            if is_batched:
+                # Batched processing
+                B, N, _ = vertices.shape
+                deformed_vertices = vertices.clone()
+                movable_mask = (part_mask == 1)
+
+                for b in range(B):
+                    movable_verts = vertices[b, movable_mask]  # [M, 3]
+                    transformed = dual_quaternion_apply((qr[b], qd[b]), movable_verts)
+                    deformed_vertices[b, movable_mask] = transformed
+            else:
+                # Single mesh processing
+                deformed_vertices = vertices.clone()
+                movable_mask = (part_mask == 1)
+                movable_verts = vertices[movable_mask]  # [M, 3]
+                transformed = dual_quaternion_apply((qr, qd), movable_verts)
+                deformed_vertices[movable_mask] = transformed
+
+        return deformed_vertices
+
+    def generate_mesh_sequence(
+        self,
+        vertices: torch.Tensor,
+        faces: torch.Tensor,
+        qr_sequence: torch.Tensor,
+        qd_sequence: torch.Tensor,
+        part_mask: torch.Tensor = None
+    ) -> List[trimesh.Trimesh]:
+        """
+        Generate animated mesh sequence from dual quaternion sequence.
+
+        Args:
+            vertices: Initial vertex positions [N, 3]
+            faces: Face indices [F, 3]
+            qr_sequence: Rotation quaternion sequence [T, 4]
+            qd_sequence: Translation quaternion sequence [T, 4]
+            part_mask: Which vertices are movable [N]
+
+        Returns:
+            List of trimesh objects [T frames]
+        """
+        num_frames = qr_sequence.shape[0]
+        mesh_sequence = []
+
+        vertices = vertices.to(self.device)
+        qr_sequence = qr_sequence.to(self.device)
+        qd_sequence = qd_sequence.to(self.device)
+        if part_mask is not None:
+            part_mask = part_mask.to(self.device)
+
+        for t in range(num_frames):
+            # Apply transformation for frame t
+            deformed_verts = self.apply_dualquat_to_vertices(
+                vertices,
+                qr_sequence[t],
+                qd_sequence[t],
+                part_mask
+            )
+
+            # Convert to numpy and create trimesh
+            verts_np = deformed_verts.cpu().numpy()
+            faces_np = faces.cpu().numpy() if torch.is_tensor(faces) else faces
+
+            mesh = trimesh.Trimesh(vertices=verts_np, faces=faces_np)
+            mesh_sequence.append(mesh)
+
+        return mesh_sequence
+
+    def deform_mesh_with_vae_prediction(
+        self,
+        mesh: trimesh.Trimesh,
+        qr_pred: torch.Tensor,
+        qd_pred: torch.Tensor,
+        part_mask: np.ndarray = None
+    ) -> List[trimesh.Trimesh]:
+        """
+        Deform mesh using VAE predictions.
+
+        Args:
+            mesh: Initial mesh (trimesh object)
+            qr_pred: Predicted rotation quaternions [T, 4]
+            qd_pred: Predicted translation quaternions [T, 4]
+            part_mask: Which vertices are movable [N] (numpy array)
+
+        Returns:
+            List of deformed meshes [T frames]
+        """
+        # Convert mesh to torch tensors
+        vertices = torch.from_numpy(mesh.vertices).float()
+        faces = torch.from_numpy(mesh.faces).long()
+
+        if part_mask is not None:
+            part_mask = torch.from_numpy(part_mask).long()
+
+        # Generate sequence
+        mesh_sequence = self.generate_mesh_sequence(
+            vertices, faces, qr_pred, qd_pred, part_mask
+        )
+
+        return mesh_sequence
+
+
+def visualize_deformation(
+    mesh_sequence: List[trimesh.Trimesh],
+    output_dir: str,
+    prefix: str = "frame"
+):
+    """
+    Save mesh sequence as individual OBJ files.
+
+    Args:
+        mesh_sequence: List of trimesh objects
+        output_dir: Directory to save meshes
+        prefix: Prefix for filenames
+    """
+    import os
+    os.makedirs(output_dir, exist_ok=True)
+
+    for i, mesh in enumerate(mesh_sequence):
+        output_path = os.path.join(output_dir, f"{prefix}_{i:03d}.obj")
+        mesh.export(output_path)
+
+    print(f"Saved {len(mesh_sequence)} frames to {output_dir}")
+
+
+def create_animation_video(
+    mesh_sequence: List[trimesh.Trimesh],
+    output_path: str,
+    resolution=(800, 600),
+    fps=10
+):
+    """
+    Create video from mesh sequence.
+
+    Args:
+        mesh_sequence: List of trimesh objects
+        output_path: Path to save video (e.g., 'animation.mp4')
+        resolution: Video resolution (width, height)
+        fps: Frames per second
+    """
+    try:
+        import pyrender
+        import imageio
+        import tempfile
+    except ImportError:
+        print("Warning: pyrender or imageio not installed. Cannot create video.")
+        print("Install with: pip install pyrender imageio[ffmpeg]")
+        return
+
+    # Create pyrender scene
+    scene = pyrender.Scene()
+
+    # Add camera and light
+    camera = pyrender.PerspectiveCamera(yfov=np.pi / 3.0)
+    camera_pose = np.array([
+        [1.0, 0.0, 0.0, 0.0],
+        [0.0, 1.0, 0.0, 0.0],
+        [0.0, 0.0, 1.0, 2.0],
+        [0.0, 0.0, 0.0, 1.0]
+    ])
+    scene.add(camera, pose=camera_pose)
+
+    light = pyrender.DirectionalLight(color=np.ones(3), intensity=3.0)
+    scene.add(light, pose=camera_pose)
+
+    # Render frames
+    renderer = pyrender.OffscreenRenderer(*resolution)
+    frames = []
+
+    for i, mesh in enumerate(mesh_sequence):
+        # Convert trimesh to pyrender mesh
+        mesh_pr = pyrender.Mesh.from_trimesh(mesh)
+
+        # Add mesh to scene
+        mesh_node = scene.add(mesh_pr)
+
+        # Render
+        color, _ = renderer.render(scene)
+        frames.append(color)
+
+        # Remove mesh for next frame
+        scene.remove_node(mesh_node)
+
+    # Save video
+    imageio.mimsave(output_path, frames, fps=fps)
+    print(f"Saved animation to {output_path}")
+
+    renderer.delete()
+
+
+# Example usage
+if __name__ == "__main__":
+    print("Testing Mesh Deformation Engine...")
+
+    # Create a simple test mesh (cube)
+    vertices = torch.tensor([
+        [-1, -1, -1],
+        [1, -1, -1],
+        [1, 1, -1],
+        [-1, 1, -1],
+        [-1, -1, 1],
+        [1, -1, 1],
+        [1, 1, 1],
+        [-1, 1, 1],
+    ], dtype=torch.float32)
+
+    faces = torch.tensor([
+        [0, 1, 2], [0, 2, 3],  # Front
+        [4, 5, 6], [4, 6, 7],  # Back
+        [0, 1, 5], [0, 5, 4],  # Bottom
+        [2, 3, 7], [2, 7, 6],  # Top
+        [0, 3, 7], [0, 7, 4],  # Left
+        [1, 2, 6], [1, 6, 5],  # Right
+    ])
+
+    # Part mask: top half is movable
+    part_mask = torch.tensor([0, 0, 0, 0, 1, 1, 1, 1], dtype=torch.long)
+
+    # Create a simple rotation sequence
+    num_frames = 16
+    angles = torch.linspace(0, np.pi / 2, num_frames)
+
+    qr_sequence = []
+    qd_sequence = []
+
+    for angle in angles:
+        # Rotation around Y axis
+        qr = torch.tensor([
+            np.cos(angle / 2),
+            0,
+            np.sin(angle / 2),
+            0
+        ], dtype=torch.float32)
+
+        # No translation
+        qd = torch.tensor([0, 0, 0, 0], dtype=torch.float32)
+
+        qr_sequence.append(qr)
+        qd_sequence.append(qd)
+
+    qr_sequence = torch.stack(qr_sequence)
+    qd_sequence = torch.stack(qd_sequence)
+
+    # Create deformation engine
+    engine = MeshDeformationEngine()
+
+    # Generate mesh sequence
+    print("\nGenerating mesh sequence...")
+    mesh_sequence = engine.generate_mesh_sequence(
+        vertices, faces, qr_sequence, qd_sequence, part_mask
+    )
+
+    print(f"Generated {len(mesh_sequence)} frames")
+    print(f"First frame vertices: {mesh_sequence[0].vertices.shape}")
+    print(f"Last frame vertices: {mesh_sequence[-1].vertices.shape}")
+
+    # Visualize deformation
+    print("\nSaving frames...")
+    visualize_deformation(mesh_sequence, "outputs/test_deformation", "test_cube")
+
+    print("\nTest complete!")

DragMesh/dragmesh/inference/inference_animation.py

@@ -0,0 +1,930 @@
+# -------------------------------------------------------------------
+# inference_animation.py
+# -------------------------------------------------------------------
+
+import sys
+import os
+import torch
+import numpy as np
+import trimesh
+import argparse
+from tqdm import tqdm
+from difflib import get_close_matches
+import tempfile
+import copy
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+import torch.nn.functional as F
+import math
+
+from dragmesh.models.model_v2 import DualQuaternionVAE
+from dragmesh.data.data_loader_v2 import GAPartNetLoaderV2
+from dragmesh.geometry.dual_quaternion import dual_quaternion_apply, quaternion_to_axis_angle, quaternion_multiply, quaternion_conjugate
+
+# --- Offscreen rendering (headless fallback) ---
+_OFFSCREEN_RENDERING_BROKEN = False
+
+def _maybe_set_headless_opengl_platform():
+    """
+    In headless environments (no DISPLAY), `pyrender` may default to `pyglet` and raise
+    `NoSuchDisplayException`. We set `PYOPENGL_PLATFORM` before importing pyrender to
+    prefer EGL (GPU) and fall back to OSMesa (software).
+    """
+    if os.environ.get("DISPLAY"):
+        return
+    if os.environ.get("PYOPENGL_PLATFORM"):
+        return
+    # Prefer EGL (common on GPU servers); fall back to OSMesa (software rendering).
+    os.environ["PYOPENGL_PLATFORM"] = "egl"
+
+# --- glTF animation support ---
+try:
+    import pygltflib
+    from pygltflib import GLTF2
+except ImportError:
+    print("\n--- Warning: pygltflib not installed ---")
+    print("Skipping animated GLB export. Install with: pip install pygltflib")
+    pygltflib = None
+
+# --- Helpers ---
+def project_rotation_to_axis(quaternion, target_axis):
+    """Project a quaternion to a target axis (PyTorch tensor implementation)."""
+    target_axis = target_axis.to(quaternion.device)
+    angle = 2 * torch.acos(torch.clamp(quaternion[..., 0:1].abs(), -1.0, 1.0))
+    target_axis_normalized = F.normalize(target_axis, p=2, dim=-1)
+    half_angle = angle / 2.0
+    projected_quaternion = torch.cat([
+        torch.cos(half_angle),
+        target_axis_normalized * torch.sin(half_angle)
+    ], dim=-1)
+    projected_quaternion = F.normalize(projected_quaternion, p=2, dim=-1)
+    return projected_quaternion
+
+def _nlerp_quaternion_sequence(q_start: torch.Tensor, q_end: torch.Tensor, t_values: torch.Tensor) -> torch.Tensor:
+    """
+    Normalized linear interpolation (NLERP) for quaternions.
+
+    This is used to produce a "single interaction" rotation trajectory (no cumulative spinning).
+    Args:
+        q_start/q_end: [4] (wxyz)
+        t_values: [T]
+    Returns:
+        [T, 4]
+    """
+    # Handle double cover: always take the shortest arc.
+    dot = torch.dot(q_start, q_end)
+    if dot < 0.0:
+        q_end = -q_end
+    q = (1.0 - t_values.unsqueeze(-1)) * q_start.unsqueeze(0) + t_values.unsqueeze(-1) * q_end.unsqueeze(0)
+    return F.normalize(q, p=2, dim=-1)
+
+def _make_loop_t_values(num_frames: int, loop_mode: str, device: torch.device) -> torch.Tensor:
+    """
+    loop_mode:
+      - once: 0->1
+      - pingpong: 0->1->0 (seamless looping in common viewers; avoids continuous spinning)
+    """
+    if num_frames <= 1:
+        return torch.zeros((num_frames,), device=device)
+    if loop_mode == "pingpong":
+        forward_steps = num_frames // 2 + 1
+        backward_steps = num_frames - forward_steps
+        t_fwd = torch.linspace(0.0, 1.0, steps=forward_steps, device=device)
+        if backward_steps <= 0:
+            return t_fwd
+        t_bwd_full = torch.linspace(1.0, 0.0, steps=backward_steps + 1, device=device)
+        t_bwd = t_bwd_full[1:]  # drop the duplicated 1.0
+        return torch.cat([t_fwd, t_bwd], dim=0)
+    # default: once
+    return torch.linspace(0.0, 1.0, steps=num_frames, device=device)
+
+# --- Rendering 1: GIF ---
+def create_gif(mesh_sequence, output_path, resolution=(600, 600), fps=15):
+    global _OFFSCREEN_RENDERING_BROKEN
+    if _OFFSCREEN_RENDERING_BROKEN:
+        return
+    try:
+        _maybe_set_headless_opengl_platform()
+        import pyrender
+        import imageio
+    except ImportError:
+        return
+    except Exception as e:
+        _OFFSCREEN_RENDERING_BROKEN = True
+        print(f"[WARN] Offscreen renderer init failed (headless?): {type(e).__name__}: {e}")
+        print("       Tips: (1) export GLB (install pygltflib), (2) set PYOPENGL_PLATFORM=egl/osmesa, "
+              "(3) run on a machine with a display.")
+        return
+
+    print(f"Generating GIF: {output_path}")
+    if not mesh_sequence: return
+    renderer = None
+    try:
+        scene = pyrender.Scene(ambient_light=[0.1, 0.1, 0.3], bg_color=[255, 255, 255])
+        first_mesh = mesh_sequence[0]
+
+        camera_pose = np.eye(4)
+        zoom = np.max(first_mesh.extents) * 2.5
+        camera_pose[2, 3] = zoom
+
+        angle_y = math.radians(30)
+        R_y = np.array([[math.cos(angle_y), 0, math.sin(angle_y), 0], [0, 1, 0, 0], [-math.sin(angle_y), 0, math.cos(angle_y), 0], [0, 0, 0, 1]])
+        angle_x = math.radians(-30)
+        R_x = np.array([[1, 0, 0, 0], [0, math.cos(angle_x), -math.sin(angle_x), 0], [0, math.sin(angle_x), math.cos(angle_x), 0], [0, 0, 0, 1]])
+        camera_pose = R_x @ R_y @ camera_pose
+
+        camera = pyrender.PerspectiveCamera(yfov=np.pi / 3.0)
+        scene.add(camera, pose=camera_pose)
+        scene.add(pyrender.DirectionalLight(color=[1, 1, 1], intensity=2.0), pose=camera_pose)
+        renderer = pyrender.OffscreenRenderer(*resolution)
+        frames = []
+
+        for mesh in mesh_sequence:
+            render_mesh = pyrender.Mesh.from_trimesh(mesh, smooth=True)
+            mesh_node = scene.add(render_mesh)
+            color, _ = renderer.render(scene)
+            frames.append(color)
+            scene.remove_node(mesh_node)
+
+        imageio.mimsave(output_path, frames, fps=fps)
+    except Exception as e:
+        _OFFSCREEN_RENDERING_BROKEN = True
+        print(f"[WARN] GIF render failed, skipping rendering. {type(e).__name__}: {e}")
+    finally:
+        try:
+            if renderer is not None:
+                renderer.delete()
+        except Exception:
+            pass
+
+# --- Rendering 2: MP4 ---
+def create_animation_video_local(mesh_sequence, output_path, resolution=(600, 600), fps=15):
+    global _OFFSCREEN_RENDERING_BROKEN
+    if _OFFSCREEN_RENDERING_BROKEN:
+        return
+    try:
+        _maybe_set_headless_opengl_platform()
+        import pyrender
+        import imageio
+    except ImportError:
+        return
+    except Exception as e:
+        _OFFSCREEN_RENDERING_BROKEN = True
+        print(f"[WARN] Offscreen renderer init failed (headless?): {type(e).__name__}: {e}")
+        print("       Tips: (1) export GLB (install pygltflib), (2) set PYOPENGL_PLATFORM=egl/osmesa, "
+              "(3) run on a machine with a display.")
+        return
+
+    print(f"Generating MP4: {output_path}")
+    if not mesh_sequence: return
+    renderer = None
+    try:
+        scene = pyrender.Scene(ambient_light=[0.1, 0.1, 0.3], bg_color=[255, 255, 255])
+        first_mesh = mesh_sequence[0]
+
+        camera_pose = np.eye(4)
+        zoom = np.max(first_mesh.extents) * 2.5
+        camera_pose[2, 3] = zoom
+
+        angle_y = math.radians(30)
+        R_y = np.array([[math.cos(angle_y), 0, math.sin(angle_y), 0], [0, 1, 0, 0], [-math.sin(angle_y), 0, math.cos(angle_y), 0], [0, 0, 0, 1]])
+        angle_x = math.radians(-30)
+        R_x = np.array([[1, 0, 0, 0], [0, math.cos(angle_x), -math.sin(angle_x), 0], [0, math.sin(angle_x), math.cos(angle_x), 0], [0, 0, 0, 1]])
+        camera_pose = R_x @ R_y @ camera_pose
+
+        camera = pyrender.PerspectiveCamera(yfov=np.pi / 3.0)
+        scene.add(camera, pose=camera_pose)
+        scene.add(pyrender.DirectionalLight(color=[1, 1, 1], intensity=2.0), pose=camera_pose)
+        renderer = pyrender.OffscreenRenderer(*resolution)
+        frames = []
+
+        for mesh in mesh_sequence:
+            render_mesh = pyrender.Mesh.from_trimesh(mesh, smooth=True)
+            mesh_node = scene.add(render_mesh)
+            color, _ = renderer.render(scene)
+            frames.append(color)
+            scene.remove_node(mesh_node)
+
+        # MP4 export relies on the imageio-ffmpeg backend; keep this best-effort (do not fail inference).
+        imageio.mimsave(output_path, frames, fps=fps)
+    except Exception as e:
+        _OFFSCREEN_RENDERING_BROKEN = True
+        print(f"[WARN] MP4 render failed, skipping rendering. {type(e).__name__}: {e}")
+        print("       Continuing inference outputs. For video/GIF, run with DISPLAY or configure EGL/OSMesa.")
+    finally:
+        try:
+            if renderer is not None:
+                renderer.delete()
+        except Exception:
+            pass
+
+
+# --- Core: export an animated GLB ---
+def export_animated_glb(initial_mesh, part_mask_np, qr_seq_tensor, qd_seq_tensor,
+                        joint_origin_norm_tensor, scale, center, output_path, fps=10):
+    """
+    Export an animated GLB with translation/rotation tracks.
+    """
+    if pygltflib is None:
+        return
+
+    print(f"Generating Animated GLB: {output_path}")
+
+    def _pad_to_4bytes(blob: bytearray) -> None:
+        """glTF bufferView requires 4-byte alignment (GLB viewers often rely on this)."""
+        pad = (-len(blob)) % 4
+        if pad:
+            blob.extend(b"\x00" * pad)
+
+    # 1) De-normalize joint origin back to world space.
+    real_origin = joint_origin_norm_tensor.cpu().numpy() * scale + center
+
+    # 2) Split the mesh into static vs moving parts (preserve materials via trimesh submesh).
+    try:
+        # All faces
+        faces = initial_mesh.faces
+        vertex_mask = part_mask_np.astype(bool)
+
+        # Face assignment: a face is moving iff all its vertices are marked movable.
+        # This heuristic works well for rigid part segmentations (e.g., GAPartNet).
+        face_mask = vertex_mask[faces].all(axis=1)
+
+        moving_face_ids = np.where(face_mask)[0]
+        static_face_ids = np.where(~face_mask)[0]
+
+        # Degenerate masks (all-moving or all-static): avoid empty submeshes.
+        if moving_face_ids.size == 0 or static_face_ids.size == 0:
+            initial_mesh.export(output_path)
+            return
+
+        # trimesh.submesh expects face index lists, not boolean masks.
+        mesh_moving = initial_mesh.submesh([moving_face_ids], append=True)
+        mesh_static = initial_mesh.submesh([static_face_ids], append=True)
+
+        # Name nodes for debugging.
+        mesh_moving.name = "moving_part"
+        mesh_static.name = "static_part"
+
+    except Exception as e:
+        print(f"Error splitting mesh for GLB: {e}")
+        # Fallback: export a static GLB if splitting fails.
+        initial_mesh.export(output_path)
+        return
+
+    # 3) Pivot adjustment:
+    #    A) translate moving vertices so the joint origin becomes (0, 0, 0) in its local frame
+    #    B) set the moving node translation back to the joint origin in world space
+
+    mesh_moving.vertices -= real_origin
+
+    # 4) Build a trimesh.Scene and export a base GLB (trimesh handles material packaging).
+    scene = trimesh.Scene()
+    scene.add_geometry(mesh_static, node_name='static_node')
+
+    # Initial transform: translate the moving node to the joint pivot.
+    transform_matrix = np.eye(4)
+    transform_matrix[:3, 3] = real_origin
+    scene.add_geometry(mesh_moving, node_name='moving_node', transform=transform_matrix)
+
+    # Export a temporary GLB (trimesh performs binary conversion and material handling).
+    fd, temp_glb_path = tempfile.mkstemp(suffix='.glb')
+    os.close(fd)
+    scene.export(temp_glb_path)
+
+    # 5) Inject animation data via pygltflib.
+    gltf = GLTF2().load(temp_glb_path)
+
+    # Locate the moving node index.
+    moving_node_idx = -1
+    for i, node in enumerate(gltf.nodes):
+        if node.name == 'moving_node':
+            moving_node_idx = i
+            break
+
+    # Fallback: trimesh may rename nodes; the last node is typically the last added.
+    if moving_node_idx == -1:
+         moving_node_idx = len(gltf.nodes) - 1
+
+    # --- Keyframe data ---
+    num_frames = qr_seq_tensor.shape[0]
+    times = (np.arange(num_frames, dtype=np.float32) / float(fps)).astype(np.float32)
+
+    # Force TRS on the moving node. Some exporters write node.matrix, which can cause
+    # translation/rotation tracks to be ignored in certain viewers.
+    try:
+        node = gltf.nodes[moving_node_idx]
+        if getattr(node, "matrix", None):
+            node.matrix = None
+        node.translation = real_origin.astype(np.float32).tolist()
+        if node.rotation is None:
+            node.rotation = [0.0, 0.0, 0.0, 1.0]
+        if node.scale is None:
+            node.scale = [1.0, 1.0, 1.0]
+    except Exception:
+        pass
+
+    # A) Rotation: DualQuaternion real part -> glTF quaternion.
+    # PyTorch: [w, x, y, z] -> glTF: [x, y, z, w]
+    qr_seq = qr_seq_tensor.detach().cpu().numpy().astype(np.float32)
+    # Normalize to avoid non-unit quaternions (some viewers reject them).
+    qr_norm = np.linalg.norm(qr_seq, axis=1, keepdims=True)
+    qr_norm = np.where(qr_norm < 1e-8, 1.0, qr_norm)
+    qr_seq = qr_seq / qr_norm
+    rotations = np.zeros((num_frames, 4), dtype=np.float32)
+    rotations[:, 0] = qr_seq[:, 1] # x
+    rotations[:, 1] = qr_seq[:, 2] # y
+    rotations[:, 2] = qr_seq[:, 3] # z
+    rotations[:, 3] = qr_seq[:, 0] # w
+
+    # B) Translation:
+    # The node is already positioned at `real_origin`. The DQ translation is an offset
+    # in normalized space, so per-frame translation is: real_origin + t * scale.
+
+    qr_conj = quaternion_conjugate(qr_seq_tensor)
+    t_q = 2.0 * quaternion_multiply(qd_seq_tensor, qr_conj)
+    t_vec_norm = t_q[:, 1:].cpu().numpy() # [N, 3]
+    t_vec_real = t_vec_norm * scale
+
+    translations = np.zeros((num_frames, 3), dtype=np.float32)
+    for i in range(num_frames):
+        translations[i] = real_origin + t_vec_real[i]
+
+    # --- Write binary buffer ---
+    blob = bytearray(gltf.binary_blob())
+    _pad_to_4bytes(blob)
+
+    # 1. Times Input
+    times_bytes = times.tobytes()
+    times_offset = len(blob)
+    blob.extend(times_bytes)
+    _pad_to_4bytes(blob)
+    times_view_idx = len(gltf.bufferViews)
+    gltf.bufferViews.append(pygltflib.BufferView(buffer=0, byteOffset=times_offset, byteLength=len(times_bytes)))
+    times_accessor_idx = len(gltf.accessors)
+    gltf.accessors.append(pygltflib.Accessor(
+        bufferView=times_view_idx, componentType=pygltflib.FLOAT, count=num_frames, type=pygltflib.SCALAR,
+        min=[float(times.min())], max=[float(times.max())]
+    ))
+
+    # 2. Translations Output
+    trans_bytes = translations.tobytes()
+    trans_offset = len(blob)
+    blob.extend(trans_bytes)
+    _pad_to_4bytes(blob)
+    trans_view_idx = len(gltf.bufferViews)
+    gltf.bufferViews.append(pygltflib.BufferView(buffer=0, byteOffset=trans_offset, byteLength=len(trans_bytes)))
+    trans_accessor_idx = len(gltf.accessors)
+    gltf.accessors.append(pygltflib.Accessor(
+        bufferView=trans_view_idx, componentType=pygltflib.FLOAT, count=num_frames, type=pygltflib.VEC3,
+        min=translations.min(axis=0).tolist(), max=translations.max(axis=0).tolist()
+    ))
+
+    # 3. Rotations Output
+    rot_bytes = rotations.tobytes()
+    rot_offset = len(blob)
+    blob.extend(rot_bytes)
+    _pad_to_4bytes(blob)
+    rot_view_idx = len(gltf.bufferViews)
+    gltf.bufferViews.append(pygltflib.BufferView(buffer=0, byteOffset=rot_offset, byteLength=len(rot_bytes)))
+    rot_accessor_idx = len(gltf.accessors)
+    gltf.accessors.append(pygltflib.Accessor(
+        bufferView=rot_view_idx, componentType=pygltflib.FLOAT, count=num_frames, type=pygltflib.VEC4
+    ))
+
+    # Update blob length.
+    gltf.set_binary_blob(blob)
+    try:
+        if gltf.buffers and len(gltf.buffers) > 0:
+            gltf.buffers[0].byteLength = len(blob)
+    except Exception:
+        pass
+
+    # --- Create animation object ---
+    anim = pygltflib.Animation(name="Interaction")
+
+    # Translation Channel
+    anim.samplers.append(pygltflib.AnimationSampler(input=times_accessor_idx, output=trans_accessor_idx, interpolation=pygltflib.LINEAR))
+    anim.channels.append(pygltflib.AnimationChannel(sampler=0, target=pygltflib.AnimationChannelTarget(node=moving_node_idx, path="translation")))
+
+    # Rotation Channel
+    anim.samplers.append(pygltflib.AnimationSampler(input=times_accessor_idx, output=rot_accessor_idx, interpolation=pygltflib.LINEAR))
+    anim.channels.append(pygltflib.AnimationChannel(sampler=1, target=pygltflib.AnimationChannelTarget(node=moving_node_idx, path="rotation")))
+
+    gltf.animations.append(anim)
+
+    # Save final GLB.
+    gltf.save(output_path)
+
+    # Cleanup.
+    if os.path.exists(temp_glb_path):
+        os.remove(temp_glb_path)
+
+    print(f" Animated GLB saved: {output_path}")
+
+
+# --- Loader ---
+class FixedGAPartNetLoader(GAPartNetLoaderV2):
+    """Loader for a flat directory layout (one object per subfolder)."""
+    def _get_object_list(self):
+        object_list = []
+        if not os.path.isdir(self.dataset_root):
+            print(f"Error: dataset root does not exist: '{self.dataset_root}'")
+            return object_list
+        for obj_id in os.listdir(self.dataset_root):
+            obj_path = os.path.join(self.dataset_root, obj_id)
+            if not os.path.isdir(obj_path):
+                continue
+            urdf_path = os.path.join(obj_path, "mobility_annotation_gapartnet.urdf")
+            if os.path.exists(urdf_path):
+                object_list.append(obj_path)
+        return sorted(object_list)
+
+
+def load_model(checkpoint_path, device, args):
+    """Load the VAE model from a checkpoint."""
+    try:
+        checkpoint = torch.load(checkpoint_path, map_location='cpu')
+    except Exception as e:
+        print(f"Error: unable to load checkpoint: {e}")
+        return None, 16
+
+    if 'model_state_dict' not in checkpoint:
+        print("Error: checkpoint is missing 'model_state_dict'.")
+        return None, 16
+
+    model_state_dict = checkpoint['model_state_dict']
+    config = checkpoint.get('config', {})
+
+    latent_dim = config.get('latent_dim', args.latent_dim)
+    num_frames = args.num_frames if args.num_frames is not None else config.get('num_frames', 16)
+    transformer_layers = config.get('transformer_layers', args.transformer_layers)
+    transformer_heads = config.get('transformer_heads', args.transformer_heads)
+
+    print(f"\n=== Initializing VAE Model ===")
+    print(f" Info: layers={transformer_layers}, heads={transformer_heads}, latent={latent_dim}")
+
+    model = DualQuaternionVAE(
+        latent_dim=latent_dim,
+        num_frames=num_frames,
+        transformer_layers=transformer_layers,
+        transformer_heads=transformer_heads
+    ).to(device)
+
+    from collections import OrderedDict
+    new_state_dict = OrderedDict()
+    for k, v in model_state_dict.items():
+        if k.startswith('module.'):
+            name = k[7:]
+            new_state_dict[name] = v
+        else:
+            new_state_dict[k] = v
+
+    try:
+        model.load_state_dict(new_state_dict, strict=True)
+        print(f" Loaded with strict=True.")
+    except RuntimeError as e:
+        print(f"Warning: Strict load failed, trying loose load. Error: {str(e)[:100]}...")
+        model.load_state_dict(new_state_dict, strict=False)
+
+    model.eval()
+    return model, num_frames
+
+
+def run_vae_diversity_test(model, loader, sample_idx, device, output_dir, num_frames, num_samples_to_gen, force_rotation=False, fps: float = 5.0, loop_mode: str = "pingpong"):
+    """
+    Run VAE sampling for a single input condition and export animations (GLB/GIF/MP4).
+    """
+    print(f"\n{'='*60}\nRunning VAE Diversity Test on sample index {sample_idx}\n{'='*60}\n")
+    try:
+        fps = float(fps)
+    except Exception:
+        fps = 5.0
+    if fps <= 0:
+        fps = 5.0
+    if loop_mode not in ["once", "pingpong"]:
+        loop_mode = "pingpong"
+
+    sample = loader.generate_training_sample(sample_idx, num_frames=num_frames)
+    if sample is None:
+        print(f"Error: unable to generate a valid sample for index={sample_idx}.")
+        return
+
+    # --- 1) Prepare inputs (normalization) ---
+    initial_mesh = sample['initial_mesh']
+    vertex_part_mask = sample['part_mask']
+
+    bounds = initial_mesh.bounds
+    center = (bounds[0] + bounds[1]) / 2.0
+    scale = (bounds[1] - bounds[0]).max()
+    if scale < 1e-6: scale = 1.0
+
+    initial_mesh_normalized = initial_mesh.copy()
+    initial_mesh_normalized.vertices = (initial_mesh_normalized.vertices - center) / scale
+
+    initial_pc, face_indices = trimesh.sample.sample_surface(initial_mesh_normalized, 4096)
+
+    sampled_part_mask_np = np.zeros(4096, dtype=np.float32)
+    for i, fid in enumerate(face_indices):
+        face_vertices = initial_mesh.faces[fid]
+        face_mask_values = vertex_part_mask[face_vertices]
+        sampled_part_mask_np[i] = np.bincount(face_mask_values.astype(int)).argmax()
+
+    part_mask_bool_idx_torch = torch.from_numpy(vertex_part_mask).bool().to(device)
+
+    # --- 2) Prepare ground-truth conditions ---
+    drag_point_norm = (sample['drag_point'] - center) / scale
+    drag_vector_norm = sample['drag_vector'] / scale
+    joint_type_str = sample['joint_type']
+
+    joint_type = 0 if joint_type_str in ['revolute', 'continuous'] else 1
+    if force_rotation:
+        joint_type = 0
+        print("*** Forcing rotation mode (joint_type=0) ***")
+
+    joint_axis_gt = sample['joint_axis']
+    joint_origin_gt_norm = (sample['joint_origin'] - center) / scale
+
+    rotation_direction_gt = sample.get('rotation_direction')
+    trajectory_vectors_gt = sample.get('trajectory_vectors')
+    drag_trajectory_gt = sample.get('drag_trajectory')
+
+    # --- 3) Tensorize ---
+    pc_tensor = torch.from_numpy(initial_pc).float().unsqueeze(0).to(device)
+    part_mask_tensor = torch.from_numpy(sampled_part_mask_np).float().unsqueeze(0).to(device)
+    drag_point_tensor = torch.from_numpy(drag_point_norm).float().unsqueeze(0).to(device)
+    drag_vector_tensor = torch.from_numpy(drag_vector_norm).float().unsqueeze(0).to(device)
+    joint_type_tensor = torch.tensor([joint_type], dtype=torch.long).to(device)
+    joint_axis_tensor = torch.from_numpy(joint_axis_gt).float().unsqueeze(0).to(device)
+    joint_origin_tensor = torch.from_numpy(joint_origin_gt_norm).float().unsqueeze(0).to(device)
+
+    rotation_direction_tensor = None
+    if rotation_direction_gt is not None:
+        rotation_direction_tensor = torch.from_numpy(rotation_direction_gt).float().unsqueeze(0).to(device)
+    trajectory_vectors_tensor = None
+    if trajectory_vectors_gt is not None:
+        trajectory_vectors_tensor = torch.from_numpy(trajectory_vectors_gt).float().unsqueeze(0).to(device)
+    drag_trajectory_tensor = None
+
+    # --- 4) VAE encoder ---
+    print("Running model ENCODER...")
+    with torch.no_grad():
+        combined_condition_feat, joint_feat = model.encode_features(
+            mesh=pc_tensor,
+            part_mask=part_mask_tensor,
+            drag_point=drag_point_tensor,
+            drag_vector=drag_vector_tensor,
+            joint_type=joint_type_tensor,
+            joint_axis=joint_axis_tensor,
+            joint_origin=joint_origin_tensor,
+            rotation_direction=rotation_direction_tensor,
+            trajectory_vectors=trajectory_vectors_tensor,
+            drag_trajectory=drag_trajectory_tensor
+        )
+        mu = model.fc_mu(combined_condition_feat)
+        logvar = model.fc_logvar(combined_condition_feat)
+
+    # --- 5) Output directory ---
+    chosen_id = os.path.basename(loader.object_list[sample_idx])
+    output_dir_id = os.path.join(output_dir, chosen_id)
+    os.makedirs(output_dir_id, exist_ok=True)
+
+    # Export the static initial mesh as a reference.
+    try:
+        initial_mesh.export(os.path.join(output_dir_id, 'initial_static.glb'))
+    except:
+        pass
+
+    # --- 6) VAE decoder (multi-sample) ---
+    print(f"\nRunning model DECODER ({num_samples_to_gen} times)...")
+
+    for s_idx in range(num_samples_to_gen):
+        print(f"--- Sample {s_idx+1}/{num_samples_to_gen} ---")
+
+        with torch.no_grad():
+            if s_idx == 0 and num_samples_to_gen > 1:
+                z = mu
+            else:
+                z = model.reparameterize(mu, logvar)
+
+            pred_qr_seq, pred_qd_seq = model.decode(z, joint_feat, joint_axis_tensor, joint_type_tensor)
+
+        pred_qr_seq = pred_qr_seq.squeeze(0)
+        pred_qd_seq = pred_qd_seq.squeeze(0)
+
+        # --- 7) Apply hard constraints & build a single-interaction trajectory ---
+        if joint_type == 0: # rotation
+            pred_qd_seq = torch.zeros_like(pred_qd_seq)
+            joint_axis_expanded = joint_axis_tensor.expand(pred_qr_seq.shape[0], -1)
+            pred_qr_seq = project_rotation_to_axis(pred_qr_seq, joint_axis_expanded)
+
+        elif joint_type == 1: # translation
+            identity_qr = torch.tensor([1.0, 0.0, 0.0, 0.0], device=device)
+            pred_qr_seq = identity_qr.unsqueeze(0).expand(pred_qr_seq.shape[0], -1)
+
+            # Project translation onto the joint axis.
+            pred_qr_conj = quaternion_conjugate(pred_qr_seq)
+            pred_t_q = 2.0 * quaternion_multiply(pred_qd_seq, pred_qr_conj)
+            pred_t_vec = pred_t_q[..., 1:]
+
+            axis_vec = joint_axis_tensor.squeeze(0)
+            dot_prod = torch.sum(pred_t_vec * axis_vec, dim=-1, keepdim=True)
+            t_parallel = dot_prod * axis_vec
+            pred_qd_seq = torch.cat([torch.zeros_like(pred_t_vec[..., 0:1]), t_parallel], dim=-1) * 0.5
+
+        # --- Generate a "single interaction" trajectory (avoid cumulative spinning) ---
+        t_values = _make_loop_t_values(num_frames, loop_mode=loop_mode, device=device)
+        if joint_type == 0:  # Rotation: Identity -> final pose (NLERP)
+            qr_start = torch.tensor([1.0, 0.0, 0.0, 0.0], device=device, dtype=pred_qr_seq.dtype)
+            qr_final = pred_qr_seq[-1].clone()
+            pred_qr_seq = _nlerp_quaternion_sequence(qr_start, qr_final, t_values)
+            pred_qd_seq = torch.zeros((num_frames, 4), device=device, dtype=pred_qd_seq.dtype)
+        else:  # Translation: Identity -> final translation (LERP)
+            qr_start = torch.tensor([1.0, 0.0, 0.0, 0.0], device=device, dtype=pred_qr_seq.dtype)
+            qd_start = torch.tensor([0.0, 0.0, 0.0, 0.0], device=device, dtype=pred_qd_seq.dtype)
+            qr_final = qr_start
+            qd_final = pred_qd_seq[-1].clone()
+            # Preserve the original sign convention (translation direction may be dataset/viewer dependent).
+            qd_final = -qd_final
+            pred_qr_seq = qr_start.unsqueeze(0).expand(num_frames, -1)
+            pred_qd_seq = (1.0 - t_values.unsqueeze(-1)) * qd_start.unsqueeze(0) + t_values.unsqueeze(-1) * qd_final.unsqueeze(0)
+
+        # --- 8) Render video & GIF (best-effort) ---
+        base_output_path = os.path.join(output_dir_id, f'predicted_z_{s_idx}')
+
+        pred_mesh_sequence = []
+
+        # Precompute the mesh sequence for rendering.
+        joint_origin_t = joint_origin_tensor.squeeze(0)
+        movable_verts = verts_normalized_torch = torch.from_numpy(initial_mesh_normalized.vertices).float().to(device)
+        movable_verts_shifted = movable_verts - joint_origin_t  # shift in joint frame (mask applied later)
+
+        for i in range(num_frames):
+            qr = pred_qr_seq[i]
+            qd = pred_qd_seq[i]
+
+            # Apply dual-quaternion transform to the movable part only.
+            # 1) gather movable vertices
+            current_movable_verts = movable_verts[part_mask_bool_idx_torch]
+            current_movable_verts_shifted = current_movable_verts - joint_origin_t
+
+            # 2) transform
+            transformed_movable = dual_quaternion_apply((qr, qd), current_movable_verts_shifted)
+            transformed_movable = transformed_movable + joint_origin_t
+
+            # 3) scatter back to the full mesh
+            deformed_verts = movable_verts.clone()
+            deformed_verts[part_mask_bool_idx_torch] = transformed_movable
+
+            # 4) de-normalize to world scale
+            denormalized_verts = deformed_verts.cpu().numpy() * scale + center
+
+            # 5) build a mesh while preserving materials
+            pred_mesh = trimesh.Trimesh(vertices=denormalized_verts, faces=initial_mesh.faces, process=False)
+            pred_mesh.visual = initial_mesh.visual
+            pred_mesh_sequence.append(pred_mesh)
+
+        # Render video/GIF. Smaller fps -> slower playback. pingpong is more suitable for looping viewers.
+        create_animation_video_local(pred_mesh_sequence, base_output_path + '.mp4', fps=fps)
+        create_gif(pred_mesh_sequence, base_output_path + '.gif', fps=fps)
+
+        # --- 9) Export a single animated GLB (no per-frame OBJ export) ---
+        if pygltflib is not None:
+            export_animated_glb(
+                initial_mesh=initial_mesh,        # original mesh (with materials)
+                part_mask_np=vertex_part_mask,    # vertex segmentation mask
+                qr_seq_tensor=pred_qr_seq,        # predicted rotation sequence
+                qd_seq_tensor=pred_qd_seq,        # predicted translation (DQ) sequence
+                joint_origin_norm_tensor=joint_origin_tensor.squeeze(0), # normalized joint origin
+                scale=scale,
+                center=center,
+                output_path=base_output_path + '.glb',
+                fps=fps
+            )
+
+    print(f"\n{'='*60}\n VAE Diversity Test complete! Output saved to: {output_dir_id}\n{'='*60}")
+
+
+# --- Arguments ---
+def parse_args():
+    parser = argparse.ArgumentParser(description='VAE Animation Inference')
+    parser.add_argument('--dataset_root', type=str, required=True)
+    parser.add_argument('--checkpoint', type=str, required=True)
+    parser.add_argument('--sample_id', type=str, required=True)
+    parser.add_argument('--output_dir', type=str, default='results_animation_test')
+    parser.add_argument('--num_samples', type=int, default=1)
+    parser.add_argument('--force_rotation', action='store_true')
+    parser.add_argument('--latent_dim', type=int, default=256)
+    parser.add_argument('--num_frames', type=int, default=None)
+    # Playback FPS: smaller -> slower (affects MP4/GIF and GLB animation timeline).
+    parser.add_argument('--fps', type=float, default=5.0, help='animation playback fps (smaller = slower)')
+    parser.add_argument('--loop_mode', type=str, default='pingpong', choices=['once', 'pingpong'],
+                        help='once: 0->1; pingpong: 0->1->0 (better for default looping players)')
+    parser.add_argument('--transformer_layers', type=int, default=4)
+    parser.add_argument('--transformer_heads', type=int, default=8)
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Using device: {device}")
+
+    loader = FixedGAPartNetLoader(dataset_root=args.dataset_root)
+    if len(loader.object_list) == 0:
+        print("Error: empty dataset.")
+        return
+
+    ids_list = [os.path.basename(p) for p in loader.object_list]
+    if args.sample_id not in ids_list:
+        print(f"ERROR: Sample ID '{args.sample_id}' not found.")
+        return
+
+    idx = ids_list.index(args.sample_id)
+
+    model, actual_num_frames = load_model(args.checkpoint, device, args)
+    if model is None: return
+
+    num_frames_to_gen = args.num_frames if args.num_frames is not None else actual_num_frames
+
+    run_vae_diversity_test(
+        model, loader, idx, device, args.output_dir,
+        num_frames=num_frames_to_gen,
+        num_samples_to_gen=args.num_samples,
+        force_rotation=args.force_rotation,
+        fps=args.fps,
+        loop_mode=args.loop_mode
+    )
+
+
+if __name__ == '__main__':
+    main()
+
+def run_animation_from_sample(model, sample, sample_name, device, output_root, num_frames, num_samples_to_gen, force_rotation=False, include_groundtruth=False, fps: float = 5.0, loop_mode: str = "pingpong"):
+    """Run the inference_animation pipeline on a custom sample dict."""
+    initial_mesh = sample['initial_mesh']
+    vertex_part_mask = np.asarray(sample['part_mask'])
+    if vertex_part_mask.dtype != bool:
+        vertex_part_mask = vertex_part_mask.astype(bool)
+    bounds = initial_mesh.bounds
+    center = (bounds[0] + bounds[1]) / 2.0
+    scale = (bounds[1] - bounds[0]).max()
+    if scale < 1e-6:
+        scale = 1.0
+    initial_mesh_normalized = initial_mesh.copy()
+    initial_mesh_normalized.vertices = (initial_mesh_normalized.vertices - center) / scale
+    initial_pc, face_indices = trimesh.sample.sample_surface(initial_mesh_normalized, 4096)
+    sampled_part_mask_np = np.zeros(4096, dtype=np.float32)
+    for i, fid in enumerate(face_indices):
+        face_vertices = initial_mesh.faces[fid]
+        face_mask_values = vertex_part_mask[face_vertices]
+        sampled_part_mask_np[i] = np.bincount(face_mask_values.astype(int)).argmax()
+    part_mask_bool_idx_torch = torch.from_numpy(vertex_part_mask).bool().to(device)
+    drag_point = np.asarray(sample['drag_point'])
+    drag_vector = np.asarray(sample['drag_vector'])
+    drag_point_norm = (drag_point - center) / scale
+    drag_vector_norm = drag_vector / scale
+    joint_type_raw = sample['joint_type']
+    if isinstance(joint_type_raw, str):
+        joint_type_str = joint_type_raw
+    else:
+        joint_type_str = 'revolute' if joint_type_raw == 0 else 'prismatic'
+    joint_type = 0 if joint_type_str in ['revolute', 'continuous'] else 1
+    if force_rotation:
+        joint_type = 0
+        print('*** Forcing rotation mode (joint_type=0) ***')
+    joint_axis = np.asarray(sample['joint_axis'])
+    joint_origin = np.asarray(sample['joint_origin'])
+    joint_origin_norm = (joint_origin - center) / scale
+    rotation_direction_gt = sample.get('rotation_direction')
+    trajectory_vectors_gt = sample.get('trajectory_vectors')
+    drag_trajectory_gt = sample.get('drag_trajectory')
+    pc_tensor = torch.from_numpy(initial_pc).float().unsqueeze(0).to(device)
+    part_mask_tensor = torch.from_numpy(sampled_part_mask_np).float().unsqueeze(0).to(device)
+    drag_point_tensor = torch.from_numpy(drag_point_norm).float().unsqueeze(0).to(device)
+    drag_vector_tensor = torch.from_numpy(drag_vector_norm).float().unsqueeze(0).to(device)
+    joint_type_tensor = torch.tensor([joint_type], dtype=torch.long).to(device)
+    joint_axis_tensor = torch.from_numpy(joint_axis).float().unsqueeze(0).to(device)
+    joint_origin_tensor = torch.from_numpy(joint_origin_norm).float().unsqueeze(0).to(device)
+    rotation_direction_tensor = None if rotation_direction_gt is None else torch.from_numpy(rotation_direction_gt).float().unsqueeze(0).to(device)
+    trajectory_vectors_tensor = None if trajectory_vectors_gt is None else torch.from_numpy(trajectory_vectors_gt).float().unsqueeze(0).to(device)
+    drag_trajectory_tensor = None if drag_trajectory_gt is None else torch.from_numpy(drag_trajectory_gt).float().unsqueeze(0).to(device)
+    print('Running model ENCODER...')
+    with torch.no_grad():
+        combined_condition_feat, joint_feat = model.encode_features(
+            mesh=pc_tensor,
+            part_mask=part_mask_tensor,
+            drag_point=drag_point_tensor,
+            drag_vector=drag_vector_tensor,
+            joint_type=joint_type_tensor,
+            joint_axis=joint_axis_tensor,
+            joint_origin=joint_origin_tensor,
+            rotation_direction=rotation_direction_tensor,
+            trajectory_vectors=trajectory_vectors_tensor,
+            drag_trajectory=drag_trajectory_tensor
+        )
+        mu = model.fc_mu(combined_condition_feat)
+        logvar = model.fc_logvar(combined_condition_feat)
+    output_dir_id = os.path.join(output_root, sample_name)
+    os.makedirs(output_dir_id, exist_ok=True)
+    try:
+        initial_mesh.export(os.path.join(output_dir_id, 'initial_static.glb'))
+    except Exception:
+        pass
+    verts_normalized_torch = torch.from_numpy(initial_mesh_normalized.vertices).float().to(device)
+    faces_np = initial_mesh.faces
+    print(f"\nRunning model DECODER ({num_samples_to_gen} times)...")
+    for s_idx in range(num_samples_to_gen):
+        print(f"--- Sample {s_idx+1}/{num_samples_to_gen} ---")
+        with torch.no_grad():
+            if s_idx == 0 and num_samples_to_gen > 1:
+                z = mu
+            else:
+                z = model.reparameterize(mu, logvar)
+            pred_qr_seq, pred_qd_seq = model.decode(z, joint_feat, joint_axis_tensor, joint_type_tensor)
+        pred_qr_seq = pred_qr_seq.squeeze(0)
+        pred_qd_seq = pred_qd_seq.squeeze(0)
+        if joint_type == 0:
+            pred_qd_seq = torch.zeros_like(pred_qd_seq)
+            axis_expanded = joint_axis_tensor.expand(pred_qr_seq.shape[0], -1)
+            pred_qr_seq = project_rotation_to_axis(pred_qr_seq, axis_expanded)
+        else:
+            identity_qr = torch.tensor([1.0, 0.0, 0.0, 0.0], device=device)
+            pred_qr_seq = identity_qr.unsqueeze(0).expand(pred_qr_seq.shape[0], -1)
+            pred_qr_conj = quaternion_conjugate(pred_qr_seq)
+            pred_t_q = 2.0 * quaternion_multiply(pred_qd_seq, pred_qr_conj)
+            pred_t_vec = pred_t_q[..., 1:]
+            axis_vec = joint_axis_tensor.squeeze(0)
+            dot_prod = torch.sum(pred_t_vec * axis_vec, dim=-1, keepdim=True)
+            t_parallel = dot_prod * axis_vec
+            pred_qd_seq = torch.cat([torch.zeros_like(pred_t_vec[..., 0:1]), t_parallel], dim=-1) * 0.5
+        # Generate a "single interaction" trajectory (avoid cumulative spinning).
+        if loop_mode not in ["once", "pingpong"]:
+            loop_mode = "pingpong"
+        t_values = _make_loop_t_values(num_frames, loop_mode=loop_mode, device=device)
+        if joint_type == 0:
+            qr_start = torch.tensor([1.0, 0.0, 0.0, 0.0], device=device, dtype=pred_qr_seq.dtype)
+            qr_final = pred_qr_seq[-1].clone()
+            pred_qr_seq = _nlerp_quaternion_sequence(qr_start, qr_final, t_values)
+            pred_qd_seq = torch.zeros((num_frames, 4), device=device, dtype=pred_qd_seq.dtype)
+        else:
+            qd_final = -pred_qd_seq[-1].clone()
+            qd_start = torch.tensor([0.0, 0.0, 0.0, 0.0], device=device, dtype=pred_qd_seq.dtype)
+            qr_start = torch.tensor([1.0, 0.0, 0.0, 0.0], device=device, dtype=pred_qr_seq.dtype)
+            pred_qr_seq = qr_start.unsqueeze(0).expand(num_frames, -1)
+            pred_qd_seq = (1.0 - t_values.unsqueeze(-1)) * qd_start.unsqueeze(0) + t_values.unsqueeze(-1) * qd_final.unsqueeze(0)
+        base_output_path = os.path.join(output_dir_id, f'predicted_z_{s_idx}')
+        pred_mesh_sequence = []
+        joint_origin_t = joint_origin_tensor.squeeze(0)
+        for i in range(num_frames):
+            qr = pred_qr_seq[i]
+            qd = pred_qd_seq[i]
+            deformed_verts = verts_normalized_torch.clone()
+            movable_verts = verts_normalized_torch[part_mask_bool_idx_torch]
+            movable_verts_shifted = movable_verts - joint_origin_t
+            transformed_movable = dual_quaternion_apply((qr, qd), movable_verts_shifted)
+            transformed_movable = transformed_movable + joint_origin_t
+            deformed_verts = deformed_verts.clone()
+            deformed_verts[part_mask_bool_idx_torch] = transformed_movable
+            denormalized_verts = deformed_verts.cpu().numpy() * scale + center
+            pred_mesh = trimesh.Trimesh(vertices=denormalized_verts, faces=faces_np, process=False)
+            pred_mesh.visual = initial_mesh.visual
+            pred_mesh_sequence.append(pred_mesh)
+        create_animation_video_local(pred_mesh_sequence, base_output_path + '.mp4', fps=fps)
+        create_gif(pred_mesh_sequence, base_output_path + '.gif', fps=fps)
+        if pygltflib is not None:
+            export_animated_glb(
+                initial_mesh=initial_mesh,
+                part_mask_np=vertex_part_mask,
+                qr_seq_tensor=pred_qr_seq,
+                qd_seq_tensor=pred_qd_seq,
+                joint_origin_norm_tensor=joint_origin_tensor.squeeze(0),
+                scale=scale,
+                center=center,
+                output_path=base_output_path + '.glb',
+                fps=fps
+            )
+    if include_groundtruth and 'qr_sequence' in sample and 'qd_sequence' in sample:
+        print("Processing GROUND TRUTH animation (using GT KPs for comparison)...")
+        gt_qr_seq = torch.from_numpy(sample['qr_sequence']).float().to(device)
+        gt_qd_seq = torch.from_numpy(sample['qd_sequence']).float().to(device)
+        gt_mesh_sequence = []
+        gt_origin_tensor = torch.from_numpy((sample['joint_origin'] - center) / scale).float().to(device)
+        for i in tqdm(range(num_frames), desc="Ground Truth"):
+            qr, qd = gt_qr_seq[i], gt_qd_seq[i]
+            deformed_verts = verts_normalized_torch.clone()
+            movable_verts = verts_normalized_torch[part_mask_bool_idx_torch]
+            joint_origin_t = gt_origin_tensor.squeeze(0)
+            movable_verts_shifted = movable_verts - joint_origin_t
+            transformed_movable = dual_quaternion_apply((qr, qd), movable_verts_shifted)
+            transformed_movable = transformed_movable + joint_origin_t
+            deformed_verts[part_mask_bool_idx_torch] = transformed_movable
+            denormalized_verts = deformed_verts.cpu().numpy() * scale + center
+            gt_mesh = trimesh.Trimesh(vertices=denormalized_verts, faces=faces_np, process=False)
+            gt_mesh.visual = initial_mesh.visual
+            gt_mesh_sequence.append(gt_mesh)
+        base_gt_output_path = os.path.join(output_dir_id, 'groundtruth_gt_kps')
+        create_animation_video_local(gt_mesh_sequence, base_gt_output_path + '.mp4', fps=fps)
+        create_gif(gt_mesh_sequence, base_gt_output_path + '.gif', fps=fps)
+        print(f"{'='*60} VAE Diversity Test complete! Output saved to: {output_dir_id}{'='*60}")
+    else:
+        print(f"{'='*60}VAE Animation complete! Output saved to: {output_dir_id}{'='*60}")

DragMesh/dragmesh/inference/inference_animation_kpp.py

@@ -0,0 +1,305 @@
+"""
+inference_animation_kpp.py
+
+This script mirrors the inference/export logic in `inference_animation.py` and optionally
+overrides joint parameters using a Keypoint Predictor (KPP): joint_type / joint_axis / joint_origin.
+"""
+
+import argparse
+import os
+import sys
+from typing import Optional, Sequence, Tuple
+
+import numpy as np
+import torch
+import trimesh
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+
+from dragmesh.data.data_loader_v2 import GAPartNetLoaderV2
+from dragmesh.models.predictor import KeypointPredictor
+from dragmesh.utils.kpp_normalization import (
+    KPP_ORIGIN_NORMALIZATION,
+    denormalize_points,
+    mesh_center_scale,
+    normalize_points,
+    normalize_vector,
+)
+
+# Reuse the canonical animation logic (single-interaction trajectory, loop_mode, headless rendering
+# fallback, and animated GLB injection).
+from dragmesh.inference.inference_animation import FixedGAPartNetLoader, load_model, run_animation_from_sample
+
+
+def _parse_vec3(value: Optional[str]) -> Optional[np.ndarray]:
+    if value is None:
+        return None
+    parts = [p for p in value.replace(",", " ").split() if p]
+    if len(parts) != 3:
+        raise ValueError(f"Expected a 3D vector, got: {value!r}")
+    return np.asarray([float(p) for p in parts], dtype=np.float32)
+
+
+def load_kpp_model(checkpoint_path: str, device: torch.device) -> Optional[KeypointPredictor]:
+    try:
+        checkpoint = torch.load(checkpoint_path, map_location='cpu')
+    except Exception as exc:
+        print(f"Error: unable to load KPP checkpoint: {exc}")
+        return None
+    config = checkpoint.get('config', {})
+    ckpt_norm = config.get('origin_normalization', config.get('kpp_origin_normalization'))
+    if ckpt_norm != KPP_ORIGIN_NORMALIZATION:
+        print(
+            "[WARN] KPP checkpoint origin_normalization="
+            f"{ckpt_norm!r}; expected {KPP_ORIGIN_NORMALIZATION!r}. "
+            "Old checkpoints trained with joint-origin-centered labels predict a near-zero origin "
+            "in the normalized frame and should be retrained after rebuilding LMDB."
+        )
+    kpp_model = KeypointPredictor(
+        use_mask=config.get('use_mask', True),
+        use_drag=config.get('use_drag', True)
+    ).to(device)
+    state = {k.replace('module.', ''): v for k, v in checkpoint.get('model_state_dict', {}).items()}
+    try:
+        kpp_model.load_state_dict(state, strict=True)
+    except RuntimeError as exc:
+        print(f"[WARN] KPP strict load failed, fallback to strict=False: {exc}")
+        kpp_model.load_state_dict(state, strict=False)
+    kpp_model.eval()
+    return kpp_model
+
+
+def _prepare_kpp_inputs_from_mesh(initial_mesh: trimesh.Trimesh,
+                                  vertex_part_mask: np.ndarray,
+                                  drag_point_world: np.ndarray,
+                                  drag_vector_world: np.ndarray,
+                                  num_points: int = 4096) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, float]:
+    """
+    Match the KPP training normalization protocol:
+    - Normalize the mesh with bbox center/scale
+    - Sample a surface point cloud with `num_points`
+    - Derive per-sampled-point mask via face -> vertex majority vote (0/1)
+    - Normalize drag point/vector with the same center/scale
+    """
+    center, scale = mesh_center_scale(initial_mesh)
+
+    mesh_norm = initial_mesh.copy()
+    mesh_norm.vertices = normalize_points(mesh_norm.vertices, center, scale)
+
+    pc, face_indices = trimesh.sample.sample_surface(mesh_norm, num_points)
+
+    sampled_mask = np.zeros((len(face_indices),), dtype=np.float32)
+    # vertex_part_mask is per-vertex (bool/0/1). For each sampled point, use majority vote on its face.
+    for i, fid in enumerate(face_indices):
+        face_vertices = initial_mesh.faces[int(fid)]
+        face_mask_values = vertex_part_mask[face_vertices].astype(np.int32)
+        sampled_mask[i] = float(np.bincount(face_mask_values).argmax())
+
+    drag_point_norm = normalize_points(drag_point_world, center, scale)
+    drag_vector_norm = normalize_vector(drag_vector_world, scale)
+    return pc, sampled_mask, drag_point_norm, drag_vector_norm, center, scale
+
+
+def run_kpp_animation(model,
+                      loader: GAPartNetLoaderV2,
+                      sample_idx: int,
+                      device: torch.device,
+                      output_dir: str,
+                      num_frames: int,
+                      num_samples_to_gen: int,
+                      kpp_model: Optional[KeypointPredictor],
+                      force_rotation: bool,
+                      fps: float,
+                      loop_mode: str,
+                      use_kpp_type: bool = True,
+                      drag_point_world: Optional[Sequence[float]] = None,
+                      drag_vector_world: Optional[Sequence[float]] = None,
+                      origin_prior_world: Optional[Sequence[float]] = None,
+                      origin_from_drag_start: bool = False):
+    sample = loader.generate_training_sample(sample_idx, num_frames=num_frames)
+    if sample is None:
+        print(f"Error: unable to generate a valid sample for index={sample_idx}.")
+        return
+
+    initial_mesh = sample['initial_mesh']
+    vertex_part_mask = np.asarray(sample['part_mask'])
+    if vertex_part_mask.dtype != bool:
+        vertex_part_mask = vertex_part_mask.astype(bool)
+
+    drag_point = np.asarray(
+        sample['drag_point'] if drag_point_world is None else drag_point_world,
+        dtype=np.float32,
+    )
+    drag_vector = np.asarray(
+        sample['drag_vector'] if drag_vector_world is None else drag_vector_world,
+        dtype=np.float32,
+    )
+    if drag_point_world is not None or drag_vector_world is not None:
+        print(f"[Input] override_drag_point={drag_point.tolist()}, override_drag_vector={drag_vector.tolist()}")
+
+    # Default: use GT joint parameters (same behavior as inference_animation.py).
+    joint_type_str = sample['joint_type']
+    joint_axis = np.asarray(sample['joint_axis'], dtype=np.float32)
+    joint_origin = np.asarray(sample['joint_origin'], dtype=np.float32)
+    joint_type_int = 0 if joint_type_str in ['revolute', 'continuous'] else 1
+
+    # If KPP is provided: override joint parameters with predictions (the only difference vs animation).
+    if kpp_model is not None:
+        pc, sampled_mask, drag_point_norm, drag_vector_norm, center, scale = _prepare_kpp_inputs_from_mesh(
+            initial_mesh=initial_mesh,
+            vertex_part_mask=vertex_part_mask.astype(np.int32),
+            drag_point_world=drag_point,
+            drag_vector_world=drag_vector,
+            num_points=4096
+        )
+
+        with torch.no_grad():
+            pc_tensor = torch.from_numpy(pc).float().unsqueeze(0).to(device)
+            mask_tensor = torch.from_numpy(sampled_mask).float().unsqueeze(0).to(device)
+            drag_point_tensor = torch.from_numpy(drag_point_norm).float().unsqueeze(0).to(device)
+            drag_vector_tensor = torch.from_numpy(drag_vector_norm).float().unsqueeze(0).to(device)
+            pred_type_logits, pred_axis, pred_origin = kpp_model(
+                pc_tensor, mask_tensor, drag_point_tensor, drag_vector_tensor
+            )
+
+        pred_axis_np = pred_axis.squeeze(0).detach().cpu().numpy().astype(np.float32)
+        pred_axis_np = pred_axis_np / (np.linalg.norm(pred_axis_np) + 1e-8)
+        pred_origin_norm = pred_origin.squeeze(0).detach().cpu().numpy().astype(np.float32)
+        pred_origin_world = denormalize_points(pred_origin_norm, center, scale)
+
+        joint_axis = pred_axis_np
+        joint_origin = pred_origin_world
+        if use_kpp_type and pred_type_logits is not None:
+            joint_type_int = int(torch.argmax(pred_type_logits, dim=-1).item())
+            joint_type_str = 'revolute' if joint_type_int == 0 else 'prismatic'
+
+        if origin_prior_world is not None:
+            joint_origin = np.asarray(origin_prior_world, dtype=np.float32)
+            print("[KPP] origin_prior_world enabled; using explicit 3D anchor as joint origin prior.")
+        elif origin_from_drag_start:
+            joint_origin = drag_point.astype(np.float32)
+            print("[KPP] origin_from_drag_start enabled; using input drag point as joint origin prior.")
+
+        print(f"[KPP] origin_normalization={KPP_ORIGIN_NORMALIZATION}, center={center.tolist()}, scale={float(scale)}")
+        print(f"[KPP] joint_type={joint_type_str}, axis={joint_axis.tolist()}, origin={joint_origin.tolist()}")
+
+    if force_rotation:
+        joint_type_int = 0
+        joint_type_str = 'revolute'
+        print("*** Forcing rotation mode (joint_type=0) ***")
+
+    chosen_id = os.path.basename(loader.object_list[sample_idx])
+    output_dir_id = os.path.join(output_dir, chosen_id)
+    os.makedirs(output_dir_id, exist_ok=True)
+
+    # Build an "animation-compatible" sample dict and reuse run_animation_from_sample().
+    sample_for_anim = {
+        'initial_mesh': initial_mesh,
+        'part_mask': vertex_part_mask,
+        'drag_point': drag_point,
+        'drag_vector': drag_vector,
+        'joint_type': joint_type_str,
+        'joint_axis': joint_axis,
+        'joint_origin': joint_origin,
+        # Optional conditioning fields (keep consistent with training if available).
+        'rotation_direction': sample.get('rotation_direction'),
+        'trajectory_vectors': sample.get('trajectory_vectors'),
+        'drag_trajectory': sample.get('drag_trajectory'),
+    }
+
+    run_animation_from_sample(
+        model=model,
+        sample=sample_for_anim,
+        sample_name=chosen_id,
+        device=device,
+        output_root=output_dir,
+        num_frames=num_frames,
+        num_samples_to_gen=num_samples_to_gen,
+        force_rotation=False,  # already handled above
+        include_groundtruth=False,
+        fps=fps,
+        loop_mode=loop_mode
+    )
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='VAE Animation Inference (optionally with KPP joint prediction)')
+    parser.add_argument('--dataset_root', type=str, required=True)
+    parser.add_argument('--checkpoint', type=str, required=True, help='VAE checkpoint')
+    parser.add_argument('--sample_id', type=str, required=True)
+    parser.add_argument('--output_dir', type=str, default='results_animation_kpp')
+    parser.add_argument('--num_samples', type=int, default=1)
+    parser.add_argument('--force_rotation', action='store_true')
+    parser.add_argument('--latent_dim', type=int, default=256)
+    parser.add_argument('--num_frames', type=int, default=None)
+    parser.add_argument('--transformer_layers', type=int, default=4)
+    parser.add_argument('--transformer_heads', type=int, default=8)
+
+    parser.add_argument('--kpp_checkpoint', type=str, default=None, help='Path to KPP weights (optional)')
+    parser.add_argument('--use_kpp_type', action='store_true', default=True, help='Use KPP predicted joint type (default: True)')
+    parser.add_argument('--no_use_kpp_type', action='store_false', dest='use_kpp_type',
+                        help='Do not override joint type; only use KPP axis/origin.')
+    parser.add_argument('--drag_point_world', type=str, default=None,
+                        help='Optional manifest/user 3D drag start as "x,y,z" in world coordinates.')
+    parser.add_argument('--drag_vector_world', type=str, default=None,
+                        help='Optional manifest/user 3D drag vector as "x,y,z" in world coordinates.')
+    parser.add_argument('--origin_from_drag_start', action='store_true',
+                        help='Use the input 3D drag start as an explicit joint-origin prior.')
+    parser.add_argument('--origin_prior_world', type=str, default=None,
+                        help='Optional explicit 3D origin prior as "x,y,z"; does not alter KPP drag input.')
+
+    parser.add_argument('--fps', type=float, default=5.0, help='animation playback fps (smaller = slower)')
+    parser.add_argument('--loop_mode', type=str, default='pingpong', choices=['once', 'pingpong'],
+                        help='once: 0->1; pingpong: 0->1->0 (better for default looping players)')
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Using device: {device}")
+
+    loader = FixedGAPartNetLoader(dataset_root=args.dataset_root)
+    if len(loader.object_list) == 0:
+        print("Error: empty dataset.")
+        return
+
+    ids_list = [os.path.basename(p) for p in loader.object_list]
+    if args.sample_id not in ids_list:
+        print(f"ERROR: Sample ID '{args.sample_id}' not found.")
+        return
+
+    idx = ids_list.index(args.sample_id)
+
+    vae_model, actual_num_frames = load_model(args.checkpoint, device, args)
+    if vae_model is None:
+        return
+
+    num_frames_to_gen = args.num_frames if args.num_frames is not None else actual_num_frames
+
+    kpp_model = None
+    if args.kpp_checkpoint:
+        kpp_model = load_kpp_model(args.kpp_checkpoint, device=device)
+
+    run_kpp_animation(
+        model=vae_model,
+        loader=loader,
+        sample_idx=idx,
+        device=device,
+        output_dir=args.output_dir,
+        num_frames=num_frames_to_gen,
+        num_samples_to_gen=args.num_samples,
+        kpp_model=kpp_model,
+        force_rotation=args.force_rotation,
+        fps=args.fps,
+        loop_mode=args.loop_mode,
+        use_kpp_type=args.use_kpp_type,
+        drag_point_world=_parse_vec3(args.drag_point_world),
+        drag_vector_world=_parse_vec3(args.drag_vector_world),
+        origin_prior_world=_parse_vec3(args.origin_prior_world),
+        origin_from_drag_start=args.origin_from_drag_start
+    )
+
+
+if __name__ == '__main__':
+    main()

DragMesh/dragmesh/utils/logger.py

@@ -0,0 +1,245 @@
+"""
+Logging utilities for TensorBoard, Weights & Biases, and file logging.
+"""
+import os
+import logging
+from datetime import datetime
+from typing import Dict, Optional, Any
+
+
+class Logger:
+    """Unified logger for TensorBoard, W&B, and file logging."""
+
+    def __init__(self, log_dir: str, use_tensorboard: bool = True, use_wandb: bool = False,
+                 wandb_project: Optional[str] = None, wandb_config: Optional[Dict] = None,
+                 use_file_logging: bool = True):
+        """
+        Initialize logger.
+
+        Args:
+            log_dir: Directory for logs
+            use_tensorboard: Whether to use TensorBoard
+            use_wandb: Whether to use Weights & Biases
+            wandb_project: W&B project name
+            wandb_config: W&B configuration dict
+            use_file_logging: Whether to log to file
+        """
+        self.use_tensorboard = use_tensorboard
+        self.use_wandb = use_wandb
+        self.use_file_logging = use_file_logging
+        self.log_dir = log_dir
+
+        # Initialize file logger
+        if self.use_file_logging:
+            self._init_file_logger()
+
+        # Initialize TensorBoard
+        if self.use_tensorboard:
+            try:
+                from torch.utils.tensorboard import SummaryWriter
+                self.tb_writer = SummaryWriter(log_dir=log_dir)
+                self.log_info(f"✓ TensorBoard logging to: {log_dir}")
+            except ImportError:
+                self.log_warning("⚠ TensorBoard not available. Install with: pip install tensorboard")
+                self.use_tensorboard = False
+                self.tb_writer = None
+        else:
+            self.tb_writer = None
+
+        # Initialize Weights & Biases
+        if self.use_wandb:
+            try:
+                import wandb
+                wandb.init(project=wandb_project, config=wandb_config, dir=log_dir)
+                self.log_info(f"✓ Weights & Biases logging to project: {wandb_project}")
+            except ImportError:
+                self.log_warning("⚠ W&B not available. Install with: pip install wandb")
+                self.use_wandb = False
+            except Exception as e:
+                self.log_warning(f"⚠ W&B initialization failed: {e}")
+                self.use_wandb = False
+
+    def _init_file_logger(self):
+        """Initialize file logger."""
+        os.makedirs(self.log_dir, exist_ok=True)
+
+        # Create log file with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        log_file = os.path.join(self.log_dir, f'training_{timestamp}.log')
+
+        # Configure logger
+        self.file_logger = logging.getLogger('training_logger')
+        self.file_logger.setLevel(logging.INFO)
+
+        # Remove existing handlers to avoid duplicates
+        self.file_logger.handlers = []
+
+        # File handler
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(logging.INFO)
+
+        # Console handler (optional, for debugging)
+        # console_handler = logging.StreamHandler()
+        # console_handler.setLevel(logging.INFO)
+
+        # Formatter
+        formatter = logging.Formatter(
+            '%(asctime)s - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        file_handler.setFormatter(formatter)
+
+        self.file_logger.addHandler(file_handler)
+        # self.file_logger.addHandler(console_handler)
+
+        print(f"✓ File logging to: {log_file}")
+
+    def log_info(self, message: str):
+        """Log info message to file."""
+        if self.use_file_logging:
+            self.file_logger.info(message)
+
+    def log_warning(self, message: str):
+        """Log warning message to file."""
+        if self.use_file_logging:
+            self.file_logger.warning(message)
+        else:
+            print(message)
+
+    def log_error(self, message: str):
+        """Log error message to file."""
+        if self.use_file_logging:
+            self.file_logger.error(message)
+        else:
+            print(message)
+
+    def log_scalar(self, tag: str, value: float, step: int):
+        """Log a scalar value."""
+        if self.use_tensorboard and self.tb_writer is not None:
+            self.tb_writer.add_scalar(tag, value, step)
+
+        if self.use_wandb:
+            import wandb
+            wandb.log({tag: value}, step=step)
+
+    def log_scalars(self, main_tag: str, tag_scalar_dict: Dict[str, float], step: int):
+        """Log multiple scalar values."""
+        if self.use_tensorboard and self.tb_writer is not None:
+            self.tb_writer.add_scalars(main_tag, tag_scalar_dict, step)
+
+        if self.use_wandb:
+            import wandb
+            log_dict = {f"{main_tag}/{k}": v for k, v in tag_scalar_dict.items()}
+            wandb.log(log_dict, step=step)
+
+    def log_metrics(self, metrics: Dict[str, Any], step: int, prefix: str = ""):
+        """
+        Log multiple metrics at once.
+
+        Args:
+            metrics: Dictionary of metric names and values
+            step: Global step number
+            prefix: Prefix for metric names (e.g., 'train/', 'val/')
+        """
+        for key, value in metrics.items():
+            tag = f"{prefix}{key}" if prefix else key
+            self.log_scalar(tag, value, step)
+
+    def log_epoch_summary(self, epoch: int, train_metrics: Dict[str, float],
+                         val_metrics: Dict[str, float], extra_info: Optional[Dict[str, Any]] = None):
+        """
+        Log epoch summary to file.
+
+        Args:
+            epoch: Epoch number
+            train_metrics: Training metrics
+            val_metrics: Validation metrics
+            extra_info: Additional info to log (e.g., lr, kl_weight)
+        """
+        if not self.use_file_logging:
+            return
+
+        summary_lines = [
+            "",
+            "="*80,
+            f"Epoch {epoch} Summary",
+            "="*80
+        ]
+
+        # Training metrics
+        summary_lines.append("\nTraining Metrics:")
+        for key, value in train_metrics.items():
+            if isinstance(value, float):
+                summary_lines.append(f"  {key}: {value:.6f}")
+            else:
+                summary_lines.append(f"  {key}: {value}")
+
+        # Validation metrics
+        summary_lines.append("\nValidation Metrics:")
+        for key, value in val_metrics.items():
+            if isinstance(value, float):
+                summary_lines.append(f"  {key}: {value:.6f}")
+            else:
+                summary_lines.append(f"  {key}: {value}")
+
+        # Extra info
+        if extra_info:
+            summary_lines.append("\nAdditional Info:")
+            for key, value in extra_info.items():
+                if isinstance(value, float):
+                    summary_lines.append(f"  {key}: {value:.6f}")
+                else:
+                    summary_lines.append(f"  {key}: {value}")
+
+        summary_lines.append("="*80)
+        summary_lines.append("")
+
+        # Log all lines
+        for line in summary_lines:
+            self.file_logger.info(line)
+
+    def close(self):
+        """Close all loggers."""
+        if self.use_tensorboard and self.tb_writer is not None:
+            self.tb_writer.close()
+
+        if self.use_wandb:
+            import wandb
+            wandb.finish()
+
+        if self.use_file_logging:
+            self.log_info("Training session ended.")
+            # Close file handlers
+            for handler in self.file_logger.handlers[:]:
+                handler.close()
+                self.file_logger.removeHandler(handler)
+
+
+def create_logger(output_dir: str, use_tensorboard: bool = True, use_wandb: bool = False,
+                  wandb_project: Optional[str] = None, wandb_config: Optional[Dict] = None,
+                  use_file_logging: bool = True) -> Logger:
+    """
+    Create a logger instance.
+
+    Args:
+        output_dir: Output directory for logs
+        use_tensorboard: Whether to use TensorBoard
+        use_wandb: Whether to use W&B
+        wandb_project: W&B project name
+        wandb_config: W&B configuration dict
+        use_file_logging: Whether to log to file
+
+    Returns:
+        Logger instance
+    """
+    log_dir = os.path.join(output_dir, 'logs')
+    os.makedirs(log_dir, exist_ok=True)
+
+    return Logger(
+        log_dir=log_dir,
+        use_tensorboard=use_tensorboard,
+        use_wandb=use_wandb,
+        wandb_project=wandb_project,
+        wandb_config=wandb_config,
+        use_file_logging=use_file_logging
+    )

upstream/flash-linear-attention/tests/ops/test_delta.py

@@ -0,0 +1,296 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import pytest
+import torch
+import torch.nn.functional as F
+
+from fla.ops.delta_rule import chunk_delta_rule, fused_recurrent_delta_rule
+from fla.utils import COMPILER_MODE, assert_close, device, device_platform
+
+if COMPILER_MODE:
+    test_b_list = [1]
+    test_t_list = [4096]
+    test_t_varlen_list = test_t_list
+    test_d_list = [64, 128, 256]
+else:
+    test_b_list = [2]
+    test_t_list = [15, 63, 300, 512]
+    test_t_varlen_list = [63, 286, 300, 512]
+    test_d_list = [64, 32, 100, 256]
+test_h_list = [2]
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('scale', [1])
+@pytest.mark.parametrize('dtype', [torch.bfloat16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+@pytest.mark.skipif(
+    device_platform == 'intel',
+    reason='Intel Triton Failure'
+)
+def test_chunk(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    dtype: torch.dtype,
+    scale: float,
+):
+    torch.manual_seed(42)
+    q = torch.randn(B, T, H, D, dtype=dtype)
+    k = F.normalize(torch.randn(B, T, H, D, dtype=torch.float32), p=2, dim=-1).to(dtype)
+    v = torch.randn(B, T, H, D, dtype=dtype)
+    beta = torch.rand(B, T, H, dtype=dtype).sigmoid()
+    h0 = torch.randn(B, H, D, D, dtype=torch.float32)
+    q, k, v, beta, h0 = map(lambda x: x.to(device).requires_grad_(True), (q, k, v, beta, h0))
+    do = torch.rand_like(v)
+    dht = torch.rand_like(h0)
+
+    tri, tri_ht = chunk_delta_rule(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_dbeta, tri_dh0 = q.grad, k.grad, v.grad, beta.grad, h0.grad
+    q.grad = k.grad = v.grad = beta.grad = h0.grad = None
+
+    ref, ref_ht = fused_recurrent_delta_rule(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+    )
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_dbeta, ref_dh0 = q.grad, k.grad, v.grad, beta.grad, h0.grad
+
+    assert_close('  o', ref, tri, 0.006)
+    assert_close(' ht', ref_ht, tri_ht, 0.006)
+    assert_close(' dq', ref_dq, tri_dq, 0.008)
+    assert_close(' dk', ref_dk, tri_dk, 0.008)
+    assert_close(' dv', ref_dv, tri_dv, 0.008)
+    assert_close(' db', ref_dbeta, tri_dbeta, 0.008)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.008)
+
+
+@pytest.mark.parametrize('N', [4])
+@pytest.mark.parametrize('T', test_t_varlen_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('scale', [1])
+@pytest.mark.parametrize('dtype', [torch.bfloat16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '1',
+    reason='Skipping test_chunk_varlen because SKIP_TEST_CHUNK_VARLEN is set'
+)
+@pytest.mark.skipif(
+    device_platform == 'intel',
+    reason='Intel Triton Failure'
+)
+def test_chunk_varlen(
+    N: int,
+    T: int,
+    H: int,
+    D: int,
+    scale: float,
+    dtype: torch.dtype,
+):
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+    # randomly split the sequence into N segments
+    cu_seqlens = torch.cat([
+        torch.tensor([0], dtype=torch.long),
+        torch.arange(16, T)[torch.randperm(T - 16)[:N-1]],
+        torch.tensor([T], dtype=torch.long)
+    ], 0).to(device).sort()[0]
+    # seq-first required for inputs with variable lengths
+    q = torch.randn((1, T, H, D), dtype=dtype)
+    k = F.normalize(torch.randn(1, T, H, D, dtype=torch.float32), p=2, dim=-1).to(dtype)
+    v = torch.randn((1, T, H, D), dtype=dtype)
+    beta = torch.rand(1, T, H, dtype=dtype).sigmoid()
+    h0 = torch.randn(N, H, D, D, dtype=dtype)
+    q, k, v, beta, h0 = map(lambda x: x.to(device).requires_grad_(), (q, k, v, beta, h0))
+    do = torch.randn_like(v)
+    dht = torch.rand_like(h0)
+
+    tri, tri_ht = chunk_delta_rule(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        cu_seqlens=cu_seqlens,
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_dbeta, tri_dh0 = q.grad, k.grad, v.grad, beta.grad, h0.grad
+    q.grad = k.grad = v.grad = beta.grad = h0.grad = None
+
+    ref, ref_ht = fused_recurrent_delta_rule(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        cu_seqlens=cu_seqlens,
+    )
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_dbeta, ref_dh0 = q.grad, k.grad, v.grad, beta.grad, h0.grad
+
+    assert_close('  o', ref, tri, 0.005)
+    assert_close(' ht', ref_ht, tri_ht, 0.005)
+    assert_close(' dq', ref_dq, tri_dq, 0.008)
+    assert_close(' dk', ref_dk, tri_dk, 0.008)
+    assert_close(' dv', ref_dv, tri_dv, 0.008)
+    assert_close(' db', ref_dbeta, tri_dbeta, 0.008)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.008)
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('scale', [0.1])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.skipif(
+    device_platform == 'intel',
+    reason='Intel Triton Failure'
+)
+def test_l2_in_kernel(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    dtype: torch.dtype,
+    scale: float,
+):
+    q = torch.randn(B, T, H, D, dtype=dtype)
+    k = torch.randn(B, T, H, D, dtype=dtype)
+    v = torch.randn(B, T, H, D, dtype=dtype)
+    beta = torch.rand(B, T, H, dtype=dtype).sigmoid()
+    h0 = torch.randn(B, H, D, D, dtype=torch.float32)
+
+    q, k, v, beta, h0 = map(lambda x: x.to(device).requires_grad_(True), (q, k, v, beta, h0))
+    do = torch.rand_like(v)
+    dht = torch.rand_like(h0)
+
+    tri, tri_ht = chunk_delta_rule(
+        F.normalize(q.clone(), p=2, dim=-1).to(dtype),
+        F.normalize(k.clone(), p=2, dim=-1).to(dtype),
+        v.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_dbeta, tri_dh0 = q.grad, k.grad, v.grad, beta.grad, h0.grad
+    q.grad = k.grad = v.grad = beta.grad = h0.grad = None
+
+    ref, ref_ht = chunk_delta_rule(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        use_qk_l2norm_in_kernel=True
+    )
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_dbeta, ref_dh0 = q.grad, k.grad, v.grad, beta.grad, h0.grad
+    q.grad = k.grad = v.grad = beta.grad = h0.grad = None
+    assert_close('  o', ref, tri, 0.01)
+    assert_close(' ht', ref_ht, tri_ht, 0.01)
+    assert_close(' dq', ref_dq, tri_dq, 0.01)
+    assert_close(' dk', ref_dk, tri_dk, 0.01)
+    assert_close(' dv', ref_dv, tri_dv, 0.01)
+    assert_close(' db', ref_dbeta, tri_dbeta, 0.01)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.01)
+
+    tri, tri_ht = fused_recurrent_delta_rule(
+        F.normalize(q.clone().float(), p=2, dim=-1).to(dtype),
+        F.normalize(k.clone().float(), p=2, dim=-1).to(dtype),
+        v.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_dbeta, tri_dh0 = q.grad, k.grad, v.grad, beta.grad, h0.grad
+    q.grad = k.grad = v.grad = beta.grad = h0.grad = None
+
+    ref, ref_ht = fused_recurrent_delta_rule(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        use_qk_l2norm_in_kernel=True
+    )
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_dbeta, ref_dh0 = q.grad, k.grad, v.grad, beta.grad, h0.grad
+    q.grad = k.grad = v.grad = beta.grad = h0.grad = None
+
+    assert_close('  o', ref, tri, 0.002)
+    assert_close(' ht', ref_ht, tri_ht, 0.002)
+    assert_close(' dq', ref_dq, tri_dq, 0.002)
+    assert_close(' dk', ref_dk, tri_dk, 0.002)
+    assert_close(' dv', ref_dv, tri_dv, 0.002)
+    assert_close(' db', ref_dbeta, tri_dbeta, 0.002)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.002)
+
+    tri, tri_ht = fused_recurrent_delta_rule(
+        F.normalize(q.float().clone(), p=2, dim=-1).to(dtype),
+        F.normalize(k.float().clone(), p=2, dim=-1).to(dtype),
+        v.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_dbeta, tri_dh0 = q.grad, k.grad, v.grad, beta.grad, h0.grad
+    q.grad = k.grad = v.grad = beta.grad = h0.grad = None
+
+    ref, ref_ht = fused_recurrent_delta_rule(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        use_qk_l2norm_in_kernel=True
+    )
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_dbeta, ref_dh0 = q.grad, k.grad, v.grad, beta.grad, h0.grad
+    q.grad = k.grad = v.grad = beta.grad = h0.grad = None
+    assert_close('  o', ref, tri, 0.002)
+    assert_close(' ht', ref_ht, tri_ht, 0.002)
+    assert_close(' dq', ref_dq, tri_dq, 0.002)
+    assert_close(' dk', ref_dk, tri_dk, 0.002)
+    assert_close(' dv', ref_dv, tri_dv, 0.002)
+    assert_close(' db', ref_dbeta, tri_dbeta, 0.002)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.002)

upstream/flash-linear-attention/tests/ops/test_dplr_delta.py

@@ -0,0 +1,437 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import pytest
+import torch
+import torch.nn.functional as F
+from einops import rearrange
+
+from fla.ops.generalized_delta_rule.dplr import chunk_dplr_delta_rule, fused_recurrent_dplr_delta_rule
+from fla.utils import COMPILER_MODE, assert_close, device, device_platform
+
+if COMPILER_MODE:
+    test_b_list = [1]
+    test_t_list = [4096]
+    test_t_varlen_list = test_t_list
+    test_d_list = [64, 128, 256]
+    test_gate_list = [1.0]
+else:
+    test_b_list = [2]
+    test_t_list = [1, 15, 63, 300]
+    test_t_varlen_list = [63, 286, 300, 512]
+    test_d_list = [32, 64, 100, 256]
+    test_gate_list = [1, 0.1, 10]
+test_h_list = [2]
+
+
+def recurrent_dplr_delta_rule_ref(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    a: torch.Tensor,
+    b: torch.Tensor,
+    gk: torch.Tensor,
+    scale: float = None,
+    initial_state: torch.Tensor = None,
+    output_final_state: bool = False,
+):
+    q, k, v, a, b, gk = map(lambda x: x.transpose(1, 2).to(torch.float), (q, k, v, a, b, gk))
+
+    B, H, T, K, V = *q.shape, v.shape[-1]
+    o = torch.zeros_like(v)
+    S = torch.zeros(B, H, K, V).to(v)
+    if initial_state is not None:
+        S = initial_state
+    if scale is None:
+        scale = K ** -0.5
+    q = q * scale
+
+    for i in range(T):
+        _q = q[:, :, i]
+        _k = k[:, :, i]
+        _v = v[:, :, i].clone()
+        a_i = a[:, :, i]
+        b_i = b[:, :, i]
+        # first matmul then decay in DPLR.
+        _v2 = (S.clone() * a_i[..., None]).sum(-2)
+        S = S.clone() * gk[:, :, i].exp()[..., None]
+        S = S.clone() + _k.unsqueeze(-1) * _v.unsqueeze(-2) + b_i.unsqueeze(-1) * _v2.unsqueeze(-2)
+        o[:, :, i] = torch.einsum('bhd,bhdm->bhm', _q, S)
+    if not output_final_state:
+        S = None
+    o = o.transpose(1, 2)
+    return o, S
+
+
+def chunk_dplr_delta_rule_ref(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    a: torch.Tensor,
+    b: torch.Tensor,
+    gk: torch.Tensor,
+    initial_state: torch.Tensor = None,
+    output_final_state: bool = True,
+    scale: float = None,
+    chunk_size: int = 64,
+):
+    q, k, v, a, b, gk = map(lambda x: x.transpose(1, 2).to(torch.float), (q, k, v, a, b, gk))
+    BT = chunk_size
+    T = q.shape[-2]
+    pad_len = (BT - (T % BT)) % BT
+
+    q, k, v, a, b, gk = map(lambda x: F.pad(x, (0, 0, 0, pad_len)).to(torch.float), [q, k, v, a, b, gk])
+    B, H, _, K, V = *q.shape, v.shape[-1]
+    NT = q.shape[-2] // BT
+    if scale is None:
+        scale = K ** -0.5
+    q = q * scale
+
+    S = k.new_zeros(B, H, K, V)
+    if initial_state is not None:
+        S += initial_state
+
+    # note that diagonal is masked.
+    mask = torch.triu(torch.ones(BT, BT, dtype=torch.bool, device=q.device), diagonal=0)
+    q, k, v, a, b, gk = map(lambda x: rearrange(x, 'b h (n c) d -> b h n c d', c=BT), [q, k, v, a, b, gk])
+    gk_cumsum = gk.cumsum(-2)
+    A_ab = torch.zeros(B, H, NT, BT, BT).to(q.device)
+    A_qk = torch.zeros(B, H, NT, BT, BT).to(q.device)
+    A_ak = torch.zeros(B, H, NT, BT, BT).to(q.device)
+    A_qb = torch.zeros(B, H, NT, BT, BT).to(q.device)
+
+    for i in range(BT):
+        a_i = a[:, :, :, i, None]
+        q_i = q[:, :, :, i, None]
+        gk_i = gk_cumsum[:, :, :, i, None]
+        mask = (torch.arange(BT) <= i).to(q.device)
+        attn_i = (gk_i - gk_cumsum).masked_fill(~mask.unsqueeze(-1), float('-inf')).exp()
+        A_qk[:, :, :, i, :] = (q_i * k * attn_i).sum(-1).clone()
+        A_qb[:, :, :, i, :] = (q_i * b * attn_i).sum(-1).clone()
+        mask = (torch.arange(BT) < i).to(q.device)
+        # shift by one.
+        attn_i = (gk_i - gk[:, :, :, i, None] - gk_cumsum).masked_fill(~mask.unsqueeze(-1), float('-inf')).exp()
+        A_ab[:, :, :, i, :] = (a_i * b * attn_i).sum(-1).clone()
+        A_ak[:, :, :, i, :] = (a_i * k * attn_i).sum(-1).clone()
+
+    A_ab = A_ab
+    for i in range(1, BT):
+        A_ab[..., i, :i] = A_ab[..., i, :i].clone() + (A_ab[..., i, :, None].clone() * A_ab[..., :, :i].clone()).sum(-2)
+
+    A_ab = A_ab + torch.eye(BT, dtype=torch.float, device=q.device)
+    u = A_ab @ (A_ak @ v)
+    w = A_ab @ ((gk_cumsum-gk).exp() * a)
+
+    o = torch.zeros_like(v)
+    mask = torch.triu(torch.ones(BT, BT, dtype=torch.bool, device=q.device), diagonal=1)
+    for i in range(0, NT):
+        q_i, k_i, v_i, u_i, w_i, b_i = q[:, :, i], k[:, :, i], v[:, :, i], u[:, :, i], w[:, :, i], b[:, :, i]
+        v2_i = u_i + w_i @ S
+        o_1 = A_qk[:, :, i] @ v_i
+        o_2 = A_qb[:, :, i] @ v2_i
+        o_3 = (q_i * gk_cumsum[:, :, i].exp()) @ S
+        o[:, :, i] = o_1 + o_2 + o_3
+        decay = (gk_cumsum[:, :, i, -1, None] - gk_cumsum[:, :, i]).exp()
+        S = S*gk_cumsum[:, :, i, -1, :, None].exp() + (k_i * decay).transpose(-1, -2) @ v_i + \
+            (b_i * decay).transpose(-1, -2) @ v2_i
+
+    S = None if output_final_state is False else S
+    o = rearrange(o, 'b h n c d -> b h (n c) d')
+    o = o[:, :, :T].transpose(1, 2)
+    return o, S
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('scale', [0.25])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+def test_recurrent_fwd(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    scale: float,
+    dtype: torch.dtype,
+):
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+    os.environ['TORCH_CUDA_MATMUL_PRECISION'] = 'highest'
+    q = torch.randn(B, T, H, D, dtype=dtype)
+    k = torch.randn(B, T, H, D, dtype=dtype)
+    v = torch.randn(B, T, H, D, dtype=dtype)
+    a = torch.rand(B, T, H, D, dtype=dtype)
+    gk = torch.randn(B, T, H, D, dtype=torch.float)
+
+    a = F.normalize(a, p=2, dim=-1)
+    b = -a
+    gk = F.logsigmoid(gk) / 16
+
+    h0 = torch.randn(B, H, D, D, dtype=torch.float)
+    q, k, v, a, b, gk, h0 = map(lambda x: x.to(device).requires_grad_(False), (q, k, v, a, b, gk, h0))
+    ref, ref_ht = chunk_dplr_delta_rule_ref(
+        q=q.clone(),
+        k=k.clone(),
+        v=v.clone(),
+        a=a.clone(),
+        b=b.clone(),
+        gk=gk.clone(),
+        scale=scale,
+        initial_state=h0.clone(),
+        output_final_state=True,
+    )
+    tri, tri_ht = recurrent_dplr_delta_rule_ref(
+        q=q.clone(),
+        k=k.clone(),
+        v=v.clone(),
+        a=a.clone(),
+        b=b.clone(),
+        gk=gk.clone(),
+        scale=scale,
+        initial_state=h0.clone(),
+        output_final_state=True,
+    )
+    assert_close(' o', ref, tri, 0.001)
+    assert_close('ht', ref_ht, tri_ht, 0.001)
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('scale', [0.25])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+def test_fused_recurrent_fwd(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    scale: float,
+    dtype: torch.dtype,
+):
+    torch.manual_seed(42)
+    q = torch.randn(B, T, H, D, dtype=dtype)
+    k = torch.randn(B, T, H, D, dtype=dtype)
+    v = torch.randn(B, T, H, D, dtype=dtype)
+    a = torch.rand(B, T, H, D, dtype=dtype)
+    gk = torch.randn(B, T, H, D, dtype=torch.float)
+
+    a = F.normalize(a, p=2, dim=-1)
+    b = -a
+    gk = F.logsigmoid(gk) / 4
+
+    h0 = torch.randn(B, H, D, D, dtype=torch.float)
+    q, k, v, a, b, gk, h0 = map(lambda x: x.to(device).requires_grad_(False), (q, k, v, a, b, gk, h0))
+    ref, ref_ht = recurrent_dplr_delta_rule_ref(
+        q=q.clone(),
+        k=k.clone(),
+        v=v.clone(),
+        a=a.clone(),
+        b=b.clone(),
+        gk=gk.clone(),
+        scale=scale,
+        initial_state=h0.clone(),
+        output_final_state=True,
+    )
+
+    tri, tri_ht = fused_recurrent_dplr_delta_rule(
+        q=q.clone(),
+        k=k.clone(),
+        v=v.clone(),
+        a=a.clone(),
+        b=b.clone(),
+        gk=gk.clone(),
+        scale=scale,
+        initial_state=h0.clone(),
+        output_final_state=True,
+    )
+    assert_close(' o', ref, tri, 0.002)
+    assert_close('ht', ref_ht, tri_ht, 0.002)
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('gate_logit_normalizer', test_gate_list)
+@pytest.mark.parametrize('scale', [0.25])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.parametrize('compile', [False, True])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+@pytest.mark.skipif(
+    device_platform == 'intel',
+    reason='Intel Triton Failure'
+)
+def test_chunk(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    scale: float,
+    gate_logit_normalizer: float,
+    dtype: torch.dtype,
+    compile: bool,
+):
+    torch.manual_seed(42)
+    q = torch.randn(B, T, H, D, dtype=dtype)
+    k = torch.randn(B, T, H, D, dtype=dtype)
+    v = torch.randn(B, T, H, D, dtype=dtype)
+    a = torch.rand(B, T, H, D, dtype=dtype)
+    gk = torch.randn(B, T, H, D, dtype=torch.float)
+
+    a = F.normalize(a, p=2, dim=-1)
+    b = -a
+    gk = F.logsigmoid(gk) / gate_logit_normalizer
+
+    h0 = torch.randn(B, H, D, D, dtype=torch.float)
+    q, k, v, a, b, gk, h0 = map(lambda x: x.to(device).requires_grad_(True), (q, k, v, a, b, gk, h0))
+    ref, ref_ht = chunk_dplr_delta_rule_ref(
+        q=q.clone(),
+        k=k.clone(),
+        v=v.clone(),
+        a=a.clone(),
+        b=b.clone(),
+        gk=gk.clone(),
+        scale=scale,
+        initial_state=h0.clone(),
+        output_final_state=True,
+    )
+    do = torch.randn_like(v)
+    dht = torch.randn_like(h0)
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_da, ref_db, ref_dg, ref_dh0 = q.grad, k.grad, v.grad, a.grad, b.grad, gk.grad, h0.grad
+    q.grad = k.grad = v.grad = a.grad = b.grad = gk.grad = h0.grad = None
+
+    chunk_compiled = torch.compile(chunk_dplr_delta_rule) if compile else chunk_dplr_delta_rule
+
+    tri, tri_ht = chunk_compiled(
+        q=q.clone(),
+        k=k.clone(),
+        v=v.clone(),
+        a=a.clone(),
+        b=b.clone(),
+        gk=gk.clone(),
+        scale=scale,
+        initial_state=h0.clone(),
+        output_final_state=True,
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_da, tri_db, tri_dg, tri_dh0 = q.grad, k.grad, v.grad, a.grad, b.grad, gk.grad, h0.grad
+    q.grad = k.grad = v.grad = a.grad = b.grad = gk.grad = h0.grad = None
+
+    assert_close('  o', ref, tri, 0.007)
+    assert_close(' ht', ref_ht, tri_ht, 0.008)
+    assert_close(' dq', ref_dq, tri_dq, 0.008)
+    assert_close(' dk', ref_dk, tri_dk, 0.008)
+    assert_close(' dv', ref_dv, tri_dv, 0.008)
+    assert_close(' da', ref_da, tri_da, 0.008)
+    assert_close(' db', ref_db, tri_db, 0.008)
+    if gate_logit_normalizer >= 1 and ref_dg.norm() > 0.01:  # otherwise it is meaningless
+        assert_close(' dg', ref_dg, tri_dg, 0.008)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.008)
+
+
+@pytest.mark.parametrize('N', test_b_list)
+@pytest.mark.parametrize('T', test_t_varlen_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('scale', [0.25])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '1',
+    reason='Skipping test_chunk_varlen because SKIP_TEST_CHUNK_VARLEN is set'
+)
+@pytest.mark.skipif(
+    device_platform == 'intel',
+    reason='Intel Triton Failure'
+)
+def test_chunk_varlen(
+    N: int,
+    T: int,
+    H: int,
+    D: int,
+    scale: float,
+    dtype: torch.dtype,
+):
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+    # randomly split the sequence into N segments
+    cu_seqlens = torch.cat([
+        torch.tensor([0], dtype=torch.long),
+        torch.arange(16, T)[torch.randperm(T - 16)[:N-1]],
+        torch.tensor([T], dtype=torch.long)
+    ], 0).to(device).sort()[0]
+    # seq-first required for inputs with variable lengths
+    q = torch.randn(1, T, H, D, dtype=dtype)
+    k = torch.randn(1, T, H, D, dtype=dtype)
+    v = torch.randn(1, T, H, D, dtype=dtype)
+    a = torch.rand(1, T, H, D, dtype=dtype)
+    gk = torch.randn(1, T, H, D, dtype=torch.float)
+    a = F.normalize(a, p=2, dim=-1)
+    b = -a
+    gk = F.logsigmoid(gk)
+    h0 = torch.randn(N, H, D, D, dtype=torch.float)
+    q, k, v, a, b, gk, h0 = map(lambda x: x.to(device).requires_grad_(True), (q, k, v, a, b, gk, h0))
+
+    tri, tri_ht = chunk_dplr_delta_rule(
+        q=q.clone(),
+        k=k.clone(),
+        v=v.clone(),
+        a=a.clone(),
+        b=b.clone(),
+        gk=gk.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        cu_seqlens=cu_seqlens,
+    )
+    do = torch.randn_like(v)
+    dht = torch.randn_like(h0)
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_da, tri_db, tri_dg, tri_dh0 = q.grad, k.grad, v.grad, a.grad, b.grad, gk.grad, h0.grad
+    q.grad = k.grad = v.grad = a.grad = b.grad = gk.grad = h0.grad = None
+
+    ref = []
+    ref_ht = []
+    for i in range(N):
+        ref_i, ref_ht_i = chunk_dplr_delta_rule_ref(
+            q=q[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            k=k[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            v=v[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            a=a[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            b=b[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            gk=gk[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            scale=scale,
+            initial_state=h0[i, None],
+            output_final_state=True,
+        )
+        ref.append(ref_i)
+        ref_ht.append(ref_ht_i)
+
+    ref = torch.cat(ref, 1)
+    ref_ht = torch.cat(ref_ht, 0)
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_da, ref_db, ref_dg, ref_dh0 = q.grad, k.grad, v.grad, a.grad, b.grad, gk.grad, h0.grad
+
+    assert_close('  o', ref, tri, 0.007)
+    assert_close(' ht', ref_ht, tri_ht, 0.008)
+    assert_close(' dq', ref_dq, tri_dq, 0.008)
+    assert_close(' dk', ref_dk, tri_dk, 0.008)
+    assert_close(' dv', ref_dv, tri_dv, 0.008)
+    assert_close(' da', ref_da, tri_da, 0.008)
+    assert_close(' db', ref_db, tri_db, 0.008)
+    assert_close(' dg', ref_dg, tri_dg, 0.008)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.008)

upstream/flash-linear-attention/tests/ops/test_gated_delta.py

@@ -0,0 +1,354 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import pytest
+import torch
+import torch.nn.functional as F
+from einops import rearrange
+
+from fla.ops.gated_delta_rule import chunk_gated_delta_rule, fused_recurrent_gated_delta_rule
+from fla.utils import COMPILER_MODE, assert_close, device, is_intel_alchemist
+
+if COMPILER_MODE:
+    test_b_list = [1]
+    test_t_list = [4096]
+    test_t_varlen_list = test_t_list
+    test_d_list = [64, 128, 256]
+    test_gate_list = [1.0]
+else:
+    test_b_list = [2]
+    test_t_list = [1, 15, 63, 300]
+    test_t_varlen_list = [63, 286, 300, 512]
+    test_d_list = [64, 32, 100, 256]
+    test_gate_list = [1, 0.1, 10]
+test_h_list = [2]
+
+
+def recurrent_gated_delta_rule_ref(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    beta: torch.Tensor,
+    g: torch.Tensor,
+    scale: float = None,
+    initial_state: torch.Tensor = None,
+    output_final_state: bool = False,
+):
+    q, k, v, beta, g = map(lambda x: x.transpose(1, 2).contiguous().to(torch.float32), [q, k, v, beta, g])
+    B, H, T, K, V = *k.shape, v.shape[-1]
+    o = torch.zeros(B, H, T, V).to(v)
+    h = torch.zeros(B, H, K, V).to(v)
+    if initial_state is not None:
+        h = initial_state
+    if scale is None:
+        scale = 1 / (q.shape[-1] ** 0.5)
+    q = q * scale
+    for i in range(T):
+        b_q = q[:, :, i]
+        b_k = k[:, :, i]
+        b_v = v[:, :, i].clone()
+        h = h.clone() * g[:, :, i].exp()[..., None, None]
+        b_beta = beta[:, :, i]
+        b_v = b_v - (h.clone() * b_k[..., None]).sum(-2)
+        b_v = b_v * b_beta[..., None]
+        h = h.clone() + b_k.unsqueeze(-1) * b_v.unsqueeze(-2)
+        o[:, :, i] = torch.einsum('bhd,bhdm->bhm', b_q, h)
+    if not output_final_state:
+        h = None
+    o = o.transpose(1, 2).contiguous()
+    return o, h
+
+
+def chunk_gated_delta_rule_ref(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    g: torch.Tensor,
+    beta: torch.Tensor,
+    chunk_size: int = 64,
+    scale: float = None,
+    initial_state: torch.Tensor = None,
+    output_final_state: bool = False,
+):
+    BT = chunk_size
+    if scale is None:
+        scale = 1 / (q.shape[-1] ** 0.5)
+    # Calculate padding needed to make T a multiple of BT
+    q, k, v, beta, g = map(lambda x: x.transpose(1, 2).contiguous().to(torch.float32), [q, k, v, beta, g])
+
+    T = q.shape[-2]
+    pad_len = (BT - (T % BT)) % BT
+    if pad_len > 0:
+        # Pad all tensors
+        q = F.pad(q, (0, 0, 0, pad_len))
+        k = F.pad(k, (0, 0, 0, pad_len))
+        v = F.pad(v, (0, 0, 0, pad_len))
+        beta = F.pad(beta, (0, pad_len))
+        g = F.pad(g, (0, pad_len))
+    q, k, v, beta, g = map(lambda x: x.to(torch.float32), [q, k, v, beta, g])
+    decay = g
+    chunk_size = BT
+    b, h, l, d_k = q.shape
+    d_v = v.shape[-1]
+    q = q * scale
+    v = v * beta[..., None]
+    k_beta = k * beta[..., None]
+    assert l % chunk_size == 0
+    # note that diagonal is masked.
+    mask = torch.triu(torch.ones(chunk_size, chunk_size, dtype=torch.bool, device=q.device), diagonal=0)
+    q, k, v, k_beta, decay = map(
+        lambda x: rearrange(x, 'b h (n c) d -> b h n c d', c=chunk_size),
+        [q, k, v, k_beta, decay.unsqueeze(-1)]
+    )
+    decay = decay.squeeze(-1).cumsum(-1)
+    L_mask = ((decay.unsqueeze(-1) - decay.unsqueeze(-2)).tril().exp().float()).tril()
+    attn = -((k_beta @ k.transpose(-1, -2)) * L_mask).masked_fill(mask, 0)
+    for i in range(1, chunk_size):
+        attn[..., i, :i] = attn[..., i, :i].clone() + (attn[..., i, :i, None].clone() * attn[..., :i, :i].clone()).sum(-2)
+    attn = attn + torch.eye(chunk_size, dtype=torch.float, device=q.device)
+    attn = attn
+    k_cumsum = attn @ v
+
+    attn = -((k_beta @ k.transpose(-1, -2))).masked_fill(mask, 0)
+    for i in range(1, chunk_size):
+        attn[..., i, :i] = attn[..., i, :i].clone() + (attn[..., i, :i, None].clone() * attn[..., :i, :i].clone()).sum(-2)
+    attn = attn + torch.eye(chunk_size, dtype=torch.float, device=q.device)
+    attn = attn
+    k_cumdecay = attn @ k_beta
+    v = k_cumsum
+    S = k.new_zeros(b, h, d_k, d_v)
+    if initial_state is not None:
+        S = initial_state
+    o = torch.zeros_like(v)
+    mask = torch.triu(torch.ones(chunk_size, chunk_size, dtype=torch.bool, device=q.device), diagonal=1)
+    for i in range(0, l // chunk_size):
+        q_i, k_i, v_i = q[:, :, i], k[:, :, i], v[:, :, i]
+        attn = (q_i @ k_i.transpose(-1, -2) * L_mask[:, :, i]).masked_fill_(mask, 0)
+        v_prime = (k_cumdecay[:, :, i] * decay[:, :, i, :, None].exp()) @ S
+        v_new = v_i - v_prime
+        o_inter = (q_i * decay[:, :, i, :, None].exp()) @ S
+        o[:, :, i] = o_inter + attn @ v_new
+        S = S * decay[:, :, i, -1, None, None].exp() + (k_i * (decay[:, :, i, -1, None] - decay[:, :, i]).exp()
+                                                        [..., None]).transpose(-1, -2) @ v_new
+    if not output_final_state:
+        S = None
+    # unpad
+    o = rearrange(o, 'b h n c d -> b h (n c) d')
+    o = o[:, :, :T]
+    o = o.transpose(1, 2)
+    return o, S
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('gate_logit_normalizer', test_gate_list)
+@pytest.mark.parametrize('scale', [1])
+@pytest.mark.parametrize('use_qk_l2norm_in_kernel', [True, False])
+@pytest.mark.parametrize('dtype', [torch.float32, torch.float16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+def test_recurrent_forward(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    scale: float,
+    dtype: torch.dtype,
+    use_qk_l2norm_in_kernel: bool,
+    gate_logit_normalizer: float,
+):
+    torch.manual_seed(42)
+    q = torch.randn(B, T, H, D, dtype=torch.float32)
+    k = torch.randn(B, T, H, D, dtype=torch.float32)
+    v = torch.randn(B, T, H, D, dtype=dtype)
+    beta = torch.rand(B, T, H, dtype=dtype).sigmoid()
+    g = F.logsigmoid(torch.rand(B, T, H, dtype=torch.float32))
+    g = g / gate_logit_normalizer
+    h0 = torch.randn(B, H, D, D, dtype=torch.float32)
+    q, k, v, beta, g, h0 = map(lambda x: x.to(device).requires_grad_(), (q, k, v, beta, g, h0))
+    ref, ref_ht = recurrent_gated_delta_rule_ref(
+        q=F.normalize(q.clone(), p=2, dim=-1).to(dtype),
+        k=F.normalize(k.clone(), p=2, dim=-1).to(dtype),
+        v=v.clone(),
+        beta=beta.clone(),
+        g=g.clone(),
+        scale=scale,
+        initial_state=h0.clone(),
+        output_final_state=True,
+    )
+    tri, tri_ht = fused_recurrent_gated_delta_rule(
+        q=F.normalize(q.clone(), p=2, dim=-1).to(dtype) if not use_qk_l2norm_in_kernel else q.clone(),
+        k=F.normalize(k.clone(), p=2, dim=-1).to(dtype) if not use_qk_l2norm_in_kernel else k.clone(),
+        v=v.clone(),
+        beta=beta.clone(),
+        g=g.clone(),
+        scale=scale,
+        initial_state=h0.clone(),
+        use_qk_l2norm_in_kernel=use_qk_l2norm_in_kernel,
+        output_final_state=True,
+    )
+    assert_close('  o', ref, tri, 0.002)
+    assert_close(' ht', ref_ht, tri_ht, 0.002)
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('gate_logit_normalizer', test_gate_list)
+@pytest.mark.parametrize('scale', [1, 0.1])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+def test_chunk(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    dtype: torch.dtype,
+    scale: float,
+    gate_logit_normalizer: float
+):
+    if is_intel_alchemist and D > 128:
+        pytest.skip(reason='chunk_gated_delta_rule is not supported on alchemist for D>128')
+
+    q = torch.randn(B, T, H, D, dtype=dtype)
+    k = F.normalize(torch.randn(B, T, H, D, dtype=torch.float32), p=2, dim=-1).to(dtype)
+    v = torch.randn(B, T, H, D, dtype=dtype)
+    beta = torch.rand(B, T, H, dtype=dtype).sigmoid().fill_(1)
+    g = F.logsigmoid(torch.rand(B, T, H, dtype=torch.float32))
+    h0 = torch.zeros(B, H, D, D, dtype=torch.float32)
+    g = g / gate_logit_normalizer
+    q, k, v, beta, g, h0 = map(lambda x: x.to(device).requires_grad_(True), (q, k, v, beta, g, h0))
+
+    tri, tri_ht = chunk_gated_delta_rule(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        g.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+    )
+    do = torch.randn_like(v)
+    dht = torch.randn_like(h0)
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_dbeta, tri_dg, tri_dh0 = q.grad, k.grad, v.grad, beta.grad, g.grad, h0.grad
+    q.grad = k.grad = v.grad = beta.grad = g.grad = h0.grad = None
+
+    ref, ref_ht = chunk_gated_delta_rule_ref(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        g.clone(),
+        beta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+    )
+
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_dbeta, ref_dg, ref_dh0 = q.grad, k.grad, v.grad, beta.grad, g.grad, h0.grad
+    assert_close('  o', ref, tri, 0.005)
+    assert_close(' ht', ref_ht, tri_ht, 0.005)
+    assert_close(' dq', ref_dq, tri_dq, 0.008)
+    assert_close(' dk', ref_dk, tri_dk, 0.008)
+    assert_close(' dv', ref_dv, tri_dv, 0.008)
+    assert_close(' db', ref_dbeta, tri_dbeta, 0.02)
+    if gate_logit_normalizer >= 1 and ref_dg.norm() > 0.01:
+        assert_close(' dg', ref_dg, tri_dg, 0.02)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.008)
+
+
+@pytest.mark.parametrize('N', test_b_list)
+@pytest.mark.parametrize('T', test_t_varlen_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('scale', [1, 0.1])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '1',
+    reason='Skipping test_chunk_varlen because SKIP_TEST_CHUNK_VARLEN is set'
+)
+def test_chunk_varlen(
+    N: int,
+    T: int,
+    H: int,
+    D: int,
+    scale: float,
+    dtype: torch.dtype,
+):
+    if is_intel_alchemist and D > 128:
+        pytest.skip(reason='chunk_gated_delta_rule is not supported on alchemist for D>128')
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+    # randomly split the sequence into N segments
+    cu_seqlens = torch.cat([
+        torch.tensor([0], dtype=torch.long),
+        torch.arange(16, T)[torch.randperm(T - 16)[:N-1]],
+        torch.tensor([T], dtype=torch.long)
+    ], 0).to(device).sort()[0]
+    # seq-first required for inputs with variable lengths
+    q = torch.randn((1, T, H, D), dtype=dtype)
+    k = F.normalize(torch.randn(1, T, H, D, dtype=torch.float32), p=2, dim=-1).to(dtype)
+    v = torch.randn((1, T, H, D), dtype=dtype)
+    g = F.logsigmoid(torch.rand(1, T, H, dtype=dtype))
+    beta = torch.rand(1, T, H, dtype=dtype).sigmoid()
+    h0 = torch.randn((N, H, D, D), dtype=dtype)
+
+    q, k, v, beta, g, h0 = map(lambda x: x.to(device).requires_grad_(), (q, k, v, beta, g, h0))
+    do = torch.randn_like(v)
+    dht = torch.rand_like(h0)
+
+    tri, tri_ht = chunk_gated_delta_rule(
+        q=q.clone(),
+        k=k.clone(),
+        v=v.clone(),
+        beta=beta.clone(),
+        g=g.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        cu_seqlens=cu_seqlens,
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_dbeta, tri_dg, tri_dh0 = q.grad, k.grad, v.grad, beta.grad, g.grad, h0.grad
+    q.grad = k.grad = v.grad = beta.grad = g.grad = h0.grad = None
+
+    ref = []
+    ref_ht = []
+    for i in range(N):
+        ref_i, ref_ht_i = recurrent_gated_delta_rule_ref(
+            q=q[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            k=k[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            v=v[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            beta=beta[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            g=g[:, cu_seqlens[i]:cu_seqlens[i+1]],
+            scale=scale,
+            initial_state=h0[i],
+            output_final_state=True,
+        )
+        ref.append(ref_i)
+        ref_ht.append(ref_ht_i)
+    ref = torch.cat(ref, 1)
+    ref_ht = torch.cat(ref_ht, 0)
+
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_dbeta, ref_dg, ref_dh0 = q.grad, k.grad, v.grad, beta.grad, g.grad, h0.grad
+
+    assert_close('  o', ref, tri, 0.005)
+    assert_close(' ht', ref_ht, tri_ht, 0.005)
+    assert_close(' dq', ref_dq, tri_dq, 0.007)
+    assert_close(' dk', ref_dk, tri_dk, 0.008)
+    assert_close(' dv', ref_dv, tri_dv, 0.007)
+    assert_close(' db', ref_dbeta, tri_dbeta, 0.015)
+    assert_close(' dg', ref_dg, tri_dg, 0.015)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.007)

upstream/flash-linear-attention/tests/ops/test_gla.py

@@ -0,0 +1,250 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import pytest
+import torch
+import torch.nn.functional as F
+
+from fla.ops.gla import chunk_gla, fused_recurrent_gla
+from fla.ops.gla.naive import naive_recurrent_gla
+from fla.utils import COMPILER_MODE, assert_close, device, device_platform
+
+if COMPILER_MODE:
+    test_b_list = [1]
+    test_t_list = [4096]
+    test_t_varlen_list = test_t_list
+    test_d_list = [64, 128, 256]
+    test_gate_list = [1.0]
+else:
+    test_b_list = [2]
+    test_t_list = [1, 15, 63, 300]
+    test_t_varlen_list = [63, 286, 300, 512]
+    test_d_list = [64, 32, 100, 256]
+    test_gate_list = [1, 0.1, 10]
+test_h_list = [2]
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('dtype', [torch.float])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+@pytest.mark.skipif(
+    device_platform == 'intel',
+    reason='Intel Triton Failure'
+)
+def test_fused_recurrent(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    dtype: torch.dtype
+):
+    torch.manual_seed(42)
+
+    q = torch.randn((B, T, H, D), dtype=dtype, device=device).requires_grad_()
+    k = torch.randn((B, T, H, D), dtype=dtype, device=device).requires_grad_()
+    v = torch.randn((B, T, H, D), dtype=dtype, device=device).requires_grad_()
+    g = F.logsigmoid(torch.randn((B, T, H, D), dtype=dtype, device=device)).requires_grad_()
+    h0 = torch.randn(B, H, D, D, device=device).requires_grad_()
+
+    do = torch.randn_like(v)
+    ref, ref_ht = naive_recurrent_gla(
+        q=q,
+        k=k,
+        v=v,
+        gk=g,
+        initial_state=h0,
+        output_final_state=True
+    )
+    ((ref * do).sum()).backward()
+    ref_dq, q.grad = q.grad.clone(), None
+    ref_dk, k.grad = k.grad.clone(), None
+    ref_dv, v.grad = v.grad.clone(), None
+    ref_dg, g.grad = g.grad.clone(), None
+    ref_dh0, h0.grad = h0.grad.clone(), None
+
+    tri, tri_ht = fused_recurrent_gla(
+        q=q,
+        k=k,
+        v=v,
+        gk=g,
+        initial_state=h0,
+        output_final_state=True
+    )
+    ((tri * do).sum()).backward()
+    tri_dq, q.grad = q.grad.clone(), None
+    tri_dk, k.grad = k.grad.clone(), None
+    tri_dv, v.grad = v.grad.clone(), None
+    tri_dg, g.grad = g.grad.clone(), None
+    tri_dh0, h0.grad = h0.grad.clone(), None
+
+    assert_close('  o', ref, tri, 0.005)
+    assert_close(' ht', ref_ht, tri_ht, 0.005)
+    assert_close(' dq', ref_dq, tri_dq, 0.005)
+    assert_close(' dk', ref_dk, tri_dk, 0.005)
+    assert_close(' dv', ref_dv, tri_dv, 0.005)
+    assert_close(' dg', ref_dg, tri_dg, 0.005)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.005)
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('dtype', [torch.bfloat16])
+@pytest.mark.parametrize('gate_logit_normalizer', test_gate_list)
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+@pytest.mark.skipif(
+    device_platform == 'intel',
+    reason='Intel Triton Failure'
+)
+def test_chunk(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    dtype: torch.dtype,
+    gate_logit_normalizer: float,
+):
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+    # [B, T, H, D]
+    q = torch.randn((B, T, H, D), dtype=dtype, device=device).requires_grad_()
+    k = torch.randn((B, T, H, D), dtype=dtype, device=device).requires_grad_()
+    v = torch.randn((B, T, H, D), dtype=dtype, device=device).requires_grad_()
+    g = (F.logsigmoid(torch.randn((B, T, H, D), dtype=dtype, device=device)) / gate_logit_normalizer).requires_grad_()
+    h0 = torch.randn((B, H, D, D), dtype=dtype, device=device).requires_grad_()
+    do = torch.randn_like(v)
+    dht = torch.zeros((B, H, D, D), dtype=dtype, device=device)
+
+    tri, tri_ht = chunk_gla(
+        q,
+        k,
+        v,
+        g,
+        initial_state=h0,
+        output_final_state=True,
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward()
+    tri_dq, q.grad = q.grad.clone(), None
+    tri_dk, k.grad = k.grad.clone(), None
+    tri_dv, v.grad = v.grad.clone(), None
+    tri_dg, g.grad = g.grad.clone(), None
+    tri_dh0, h0.grad = h0.grad.clone(), None
+
+    ref, ref_ht = fused_recurrent_gla(
+        q,
+        k,
+        v,
+        g,
+        initial_state=h0,
+        output_final_state=True,
+    )
+    ref, _ = fused_recurrent_gla(
+        q,
+        k,
+        v,
+        g,
+        initial_state=h0,
+        output_final_state=False,
+    )
+    (ref * do).sum().backward()
+    ref_dq, q.grad = q.grad.clone(), None
+    ref_dk, k.grad = k.grad.clone(), None
+    ref_dv, v.grad = v.grad.clone(), None
+    ref_dg, g.grad = g.grad.clone(), None
+    ref_dh0, h0.grad = h0.grad.clone(), None
+
+    assert_close('  o', ref, tri, 0.004)
+    assert_close(' ht', ref_ht, tri_ht, 0.005)
+    assert_close(' dq', ref_dq, tri_dq, 0.005)
+    assert_close(' dk', ref_dk, tri_dk, 0.005)
+    assert_close(' dv', ref_dv, tri_dv, 0.005)
+    assert_close(' dg', ref_dg, tri_dg, 0.005)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.005)
+
+
+@pytest.mark.parametrize('N', test_b_list)
+@pytest.mark.parametrize('T', test_t_varlen_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('D', test_d_list)
+@pytest.mark.parametrize('dtype', [torch.bfloat16, torch.float])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '1',
+    reason='Skipping test_chunk_varlen because SKIP_TEST_CHUNK_VARLEN is set'
+)
+def test_chunk_varlen(
+    N: int,
+    T: int,
+    H: int,
+    D: int,
+    dtype: torch.dtype,
+):
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+    # randomly split the sequence into N segments
+    cu_seqlens = torch.cat([
+        torch.tensor([0], dtype=torch.long),
+        torch.arange(16, T)[torch.randperm(T - 16)[:N-1]],
+        torch.tensor([T], dtype=torch.long)
+    ], 0).to(device).sort()[0]
+
+    q = torch.randn((1, T, H, D), dtype=dtype, device=device).requires_grad_()
+    k = torch.randn((1, T, H, D), dtype=dtype, device=device).requires_grad_()
+    v = torch.randn((1, T, H, D), dtype=dtype, device=device).requires_grad_()
+    g = F.logsigmoid(torch.randn((1, T, H, D), dtype=dtype, device=device)).requires_grad_()
+    h0 = torch.randn((N, H, D, D), dtype=dtype, device=device).requires_grad_()
+    do = torch.randn_like(v)
+
+    ref, ref_ht = fused_recurrent_gla(
+        q, k, v, g,
+        initial_state=h0,
+        output_final_state=True,
+        cu_seqlens=cu_seqlens
+    )
+    ref, _ = fused_recurrent_gla(
+        q, k, v, g,
+        initial_state=h0,
+        output_final_state=False,
+        cu_seqlens=cu_seqlens
+    )
+
+    (ref * do).sum().backward()
+    ref_dq, q.grad = q.grad.clone(), None
+    ref_dk, k.grad = k.grad.clone(), None
+    ref_dv, v.grad = v.grad.clone(), None
+    ref_dg, g.grad = g.grad.clone(), None
+    ref_dh0, h0.grad = h0.grad.clone(), None
+
+    tri, tri_ht = chunk_gla(
+        q,
+        k,
+        v,
+        g,
+        initial_state=h0,
+        output_final_state=True,
+        cu_seqlens=cu_seqlens
+    )
+    ((tri * do).sum()).backward()
+    tri_dq, q.grad = q.grad.clone(), None
+    tri_dk, k.grad = k.grad.clone(), None
+    tri_dv, v.grad = v.grad.clone(), None
+    tri_dg, g.grad = g.grad.clone(), None
+    tri_dh0, h0.grad = h0.grad.clone(), None
+
+    assert_close('  o', ref, tri, 0.004)
+    assert_close(' ht', ref_ht, tri_ht, 0.005)
+    assert_close(' dq', ref_dq, tri_dq, 0.005)
+    assert_close(' dk', ref_dk, tri_dk, 0.005)
+    assert_close(' dv', ref_dv, tri_dv, 0.005)
+    assert_close(' dg', ref_dg, tri_dg, 0.005)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.005)

upstream/flash-linear-attention/tests/ops/test_nsa.py

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import pytest
+import torch
+import triton
+
+from fla.ops.nsa.naive import naive_nsa
+from fla.ops.nsa.parallel import parallel_nsa
+from fla.ops.utils import prepare_token_indices
+from fla.utils import COMPILER_MODE, assert_close, device
+
+if COMPILER_MODE:
+    test_b_list = [1]
+    test_t_list = [4096]
+    test_t_varlen_list = test_t_list
+else:
+    test_b_list = [2]
+    test_t_list = [256, 1024, 2000]
+    test_t_varlen_list = [63, 286, 300, 512]
+test_h_list = [2]
+
+
+# FIXME
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('HQ', [64])
+@pytest.mark.parametrize('D', [100, 64])
+@pytest.mark.parametrize('S', [16])
+@pytest.mark.parametrize('block_size', [32])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.parametrize('scale', [0.1])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+@pytest.mark.skipif(
+    True,
+    reason='TBD'
+)
+def test_parallel(
+    B: int,
+    H: int,
+    HQ: int,
+    T: int,
+    D: int,
+    S: int,
+    block_size: int,
+    dtype: torch.dtype,
+    scale: float
+):
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+
+    q = torch.randn((B, T, HQ, D), dtype=dtype, device=device).requires_grad_(True)
+    k = torch.randn((B, T, H, D), dtype=dtype, device=device).requires_grad_(True)
+    v = torch.randn((B, T, H, D), dtype=dtype, device=device).requires_grad_(True)
+    do = torch.randn((B, T, HQ, D), dtype=dtype, device=device)
+
+    block_indices = torch.full((B, T, H, S), T, dtype=torch.long, device=device)
+    for b in range(B):
+        for t in range(T):
+            for h in range(H):
+                i_i = torch.randperm(max(1, triton.cdiv(t, block_size)))[:S]
+                block_indices[b, t, h, :len(i_i)] = i_i
+    block_indices = block_indices.sort(-1)[0]
+
+    ref = naive_nsa(q=q, k=k, v=v, block_indices=block_indices, block_size=block_size, scale=scale)
+    ref.backward(do)
+    ref_dq, q.grad = q.grad.clone(), None
+    ref_dk, k.grad = k.grad.clone(), None
+    ref_dv, v.grad = v.grad.clone(), None
+
+    tri = parallel_nsa(q=q, k=k, v=v, block_indices=block_indices, block_size=block_size, scale=scale)
+    tri.backward(do)
+    tri_dq, q.grad = q.grad.clone(), None
+    tri_dk, k.grad = k.grad.clone(), None
+    tri_dv, v.grad = v.grad.clone(), None
+
+    assert_close(" o", ref, tri, 0.005)
+    assert_close("dq", ref_dq, tri_dq, 0.005)
+    assert_close("dk", ref_dk, tri_dk, 0.005)
+    assert_close("dv", ref_dv, tri_dv, 0.005)
+
+
+@pytest.mark.parametrize('N', test_b_list)
+@pytest.mark.parametrize('T', test_t_varlen_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('HQ', [64])
+@pytest.mark.parametrize('D', [100, 64])
+@pytest.mark.parametrize('S', [16])
+@pytest.mark.parametrize('block_size', [32])
+@pytest.mark.parametrize('dtype', [torch.bfloat16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '1',
+    reason='Skipping test because SKIP_TEST_CHUNK_VARLEN is set'
+)
+@pytest.mark.skipif(
+    True,
+    reason='TBD'
+)
+def test_parallel_varlen(
+    N: int,
+    T: int,
+    H: int,
+    HQ: int,
+    D: int,
+    S: int,
+    block_size: int,
+    dtype: torch.dtype,
+):
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+
+    # randomly split the sequence into N segments
+    cu_seqlens = torch.cat([
+        torch.tensor([0], dtype=torch.long),
+        torch.arange(16, T)[torch.randperm(T - 16)[:N-1]],
+        torch.tensor([T], dtype=torch.long)
+    ], 0).to(device).sort()[0]
+    # seq-first required for inputs with variable lengths
+    q = torch.randn((1, T, HQ, D), dtype=dtype, device=device).requires_grad_()
+    k = torch.randn((1, T, H, D), dtype=dtype, device=device).requires_grad_()
+    v = torch.randn((1, T, H, D), dtype=dtype, device=device).requires_grad_()
+    do = torch.randn((1, T, HQ, D), dtype=dtype, device=device)
+
+    block_indices = torch.full((1, T, H, S), T, dtype=torch.long, device=device)
+    seq_indices = prepare_token_indices(cu_seqlens).tolist()
+
+    for i in range(T):
+        _, t = seq_indices[i]
+        for h in range(H):
+            i_i = torch.randperm(max(1, triton.cdiv(t, block_size)))[:S]
+            block_indices[0, i, h, :len(i_i)] = i_i
+    block_indices = block_indices.sort(-1)[0]
+
+    ref = naive_nsa(
+        q=q,
+        k=k,
+        v=v,
+        block_indices=block_indices,
+        block_size=block_size,
+        cu_seqlens=cu_seqlens
+    )
+    ref.backward(do)
+    ref_dq, q.grad = q.grad.clone(), None
+    ref_dk, k.grad = k.grad.clone(), None
+    ref_dv, v.grad = v.grad.clone(), None
+
+    tri = parallel_nsa(
+        q=q,
+        k=k,
+        v=v,
+        block_indices=block_indices,
+        block_size=block_size,
+        cu_seqlens=cu_seqlens
+    )
+    tri.backward(do)
+    tri_dq, q.grad = q.grad.clone(), None
+    tri_dk, k.grad = k.grad.clone(), None
+    tri_dv, v.grad = v.grad.clone(), None
+
+    assert_close(' o', ref, tri, 0.004)
+    assert_close('dq', ref_dq, tri_dq, 0.005)
+    assert_close('dk', ref_dk, tri_dk, 0.005)
+    assert_close('dv', ref_dv, tri_dv, 0.005)

upstream/flash-linear-attention/tests/ops/test_retention.py

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import pytest
+import torch
+
+from fla.ops.retention import chunk_retention, fused_recurrent_retention, parallel_retention
+from fla.ops.retention.naive import naive_retention
+from fla.utils import COMPILER_MODE, assert_close, device
+
+if COMPILER_MODE:
+    test_b_list = [1]
+    test_t_list = [4096]
+    test_t_varlen_list = test_t_list
+    test_d_list = [64, 32, 100]
+else:
+    test_b_list = [2]
+    test_t_list = [1, 15, 63, 300]
+    test_t_varlen_list = [63, 286, 300, 512]
+    test_d_list = [64, 32, 100]
+test_h_list = [2]
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('K', test_d_list)
+@pytest.mark.parametrize('expand_ratio', [1, 2])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+def test_chunk(
+    B: int,
+    T: int,
+    H: int,
+    K: int,
+    expand_ratio: int,
+    dtype: torch.dtype
+):
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+    V = K * expand_ratio
+
+    q = torch.randn((B, T, H, K), dtype=dtype, device=device).requires_grad_()
+    k = torch.randn((B, T, H, K), dtype=dtype, device=device).requires_grad_()
+    v = torch.randn((B, T, H, V), dtype=dtype, device=device).requires_grad_()
+    h0 = torch.randn((B, H, K, V), dtype=dtype, device=device).requires_grad_()
+
+    do = torch.randn_like(v)
+    dht = torch.randn_like(h0)
+    ref, ref_ht = fused_recurrent_retention(q, k, v, initial_state=h0, output_final_state=True)
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward()
+    ref_dq, q.grad = q.grad.clone(), None
+    ref_dk, k.grad = k.grad.clone(), None
+    ref_dv, v.grad = v.grad.clone(), None
+
+    tri, tri_ht = chunk_retention(q, k, v, initial_state=h0, output_final_state=True)
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward()
+    tri_dq, q.grad = q.grad.clone(), None
+    tri_dk, k.grad = k.grad.clone(), None
+    tri_dv, v.grad = v.grad.clone(), None
+
+    assert_close(' o', ref, tri, 0.005)
+    assert_close('ht', ref_ht, tri_ht, 0.005)
+    assert_close('dq', ref_dq, tri_dq, 0.005)
+    assert_close('dk', ref_dk, tri_dk, 0.005)
+    assert_close('dv', ref_dv, tri_dv, 0.005)
+
+
+@pytest.mark.parametrize('N', test_b_list)
+@pytest.mark.parametrize('T', test_t_varlen_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('K', test_d_list)
+@pytest.mark.parametrize('expand_ratio', [1, 2])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '1',
+    reason='Skipping test_chunk_varlen because SKIP_TEST_CHUNK_VARLEN is set'
+)
+def test_chunk_varlen(
+    N: int,
+    T: int,
+    H: int,
+    K: int,
+    expand_ratio: int,
+    dtype: torch.dtype,
+):
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+    V = K * expand_ratio
+
+    # randomly split the sequence into N segments
+    offsets = torch.cat([
+        torch.tensor([0], dtype=torch.long),
+        torch.arange(16, T)[torch.randperm(T - 16)[:N-1]],
+        torch.tensor([T], dtype=torch.long)
+    ], 0).to(device).sort()[0]
+    # seq-first required for inputs with variable lengths
+    q = torch.randn((1, T, H, K), dtype=dtype, device=device).requires_grad_()
+    k = torch.randn((1, T, H, K), dtype=dtype, device=device).requires_grad_()
+    v = torch.randn((1, T, H, V), dtype=dtype, device=device).requires_grad_()
+    h0 = torch.randn((N, H, K, V), dtype=dtype, device=device).requires_grad_()
+    do = torch.randn_like(v)
+    dht = torch.randn_like(h0)
+
+    ref, ref_ht = fused_recurrent_retention(
+        q=q,
+        k=k,
+        v=v,
+        initial_state=h0,
+        output_final_state=True,
+        cu_seqlens=offsets,
+    )
+    ((ref * do).sum() + (ref_ht * dht).sum()).backward()
+    ref_dq, q.grad = q.grad.clone(), None
+    ref_dk, k.grad = k.grad.clone(), None
+    ref_dv, v.grad = v.grad.clone(), None
+    ref_dh0, h0.grad = h0.grad.clone(), None
+
+    tri, tri_ht = chunk_retention(
+        q=q,
+        k=k,
+        v=v,
+        initial_state=h0,
+        output_final_state=True,
+        cu_seqlens=offsets,
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum()).backward()
+    tri_dq, q.grad = q.grad.clone(), None
+    tri_dk, k.grad = k.grad.clone(), None
+    tri_dv, v.grad = v.grad.clone(), None
+    tri_dh0, h0.grad = h0.grad.clone(), None
+
+    assert_close('  o', ref, tri, 0.004)
+    assert_close(' ht', ref_ht, tri_ht, 0.005)
+    assert_close(' dq', ref_dq, tri_dq, 0.005)
+    assert_close(' dk', ref_dk, tri_dk, 0.005)
+    assert_close(' dv', ref_dv, tri_dv, 0.005)
+    assert_close('dh0', ref_dh0, tri_dh0, 0.005)
+
+
+@pytest.mark.parametrize('B', test_b_list)
+@pytest.mark.parametrize('T', test_t_list)
+@pytest.mark.parametrize('H', test_h_list)
+@pytest.mark.parametrize('K', test_d_list)
+@pytest.mark.parametrize('expand_ratio', [1, 2])
+@pytest.mark.parametrize('dtype', [torch.float16])
+@pytest.mark.skipif(
+    os.getenv('SKIP_TEST_CHUNK_VARLEN') == '0',
+    reason='Skipping test because TEST_CHUNK_VARLEN is enabled'
+)
+def test_parallel(
+    B: int,
+    T: int,
+    H: int,
+    K: int,
+    expand_ratio: int,
+    dtype: torch.dtype
+):
+    torch.manual_seed(42)
+    V = K * expand_ratio
+
+    q = torch.randn((B, T, H, K), dtype=dtype, device=device).requires_grad_()
+    k = torch.randn((B, T, H, K), dtype=dtype, device=device).requires_grad_()
+    v = torch.randn((B, T, H, V), dtype=dtype, device=device).requires_grad_()
+    do = torch.randn_like(v)
+
+    ref = naive_retention(q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)).transpose(1, 2)
+    ref.backward(do)
+    ref_dq, q.grad = q.grad.clone(), None
+    ref_dk, k.grad = k.grad.clone(), None
+    ref_dv, v.grad = v.grad.clone(), None
+
+    tri, _ = parallel_retention(q, k, v)
+    tri.backward(do)
+    tri_dq, q.grad = q.grad.clone(), None
+    tri_dk, k.grad = k.grad.clone(), None
+    tri_dv, v.grad = v.grad.clone(), None
+
+    assert_close(' o', ref, tri, 0.005)
+    assert_close('dq', ref_dq, tri_dq, 0.005)
+    assert_close('dk', ref_dk, tri_dk, 0.005)
+    assert_close('dv', ref_dv, tri_dv, 0.005)

upstream/flash-linear-attention/tests/ops/test_ttt.py

@@ -0,0 +1,305 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import pytest
+import torch
+import torch.nn.functional as F
+
+from fla.ops.ttt import chunk_ttt_linear, fused_chunk_ttt_linear
+from fla.ops.ttt.naive import chunk_ttt_linear_ref
+from fla.utils import COMPILER_MODE, assert_close, check_shared_mem, device
+
+if COMPILER_MODE:
+    test_b_list = [1]
+    test_t_list = [4096]
+    test_t_varlen_list = test_t_list
+    test_d_list = [64, 128]
+else:
+    test_b_list = [2]
+    test_t_list = [1, 15, 63, 300]
+    test_t_varlen_list = [63, 286, 300, 512]
+    test_d_list = [50, 64, 100, 128]
+test_h_list = [2]
+
+
+@pytest.mark.parametrize("B", test_b_list)
+@pytest.mark.parametrize("T", test_t_list)
+@pytest.mark.parametrize("H", test_h_list)
+@pytest.mark.parametrize("D", test_d_list)
+@pytest.mark.parametrize("scale", [0.1])
+@pytest.mark.parametrize("dtype", [torch.float16])
+@pytest.mark.parametrize("head_first", [True, False])
+@pytest.mark.skipif(
+    os.getenv("SKIP_TEST_CHUNK_VARLEN") == "0",
+    reason="Skipping test because TEST_CHUNK_VARLEN is enabled"
+)
+def test_chunk(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    dtype: torch.dtype,
+    scale: float,
+    head_first: bool
+):
+    if D > 64 and check_shared_mem('hopper') is False:
+        pytest.skip(reason="Current CI do not support this config")
+    eta_base = 5e-3
+    if head_first:
+        q = torch.randn(B, H, T, D, dtype=dtype)
+        k = F.normalize(torch.randn(B, H, T, D, dtype=torch.float32), p=2, dim=-1).to(dtype)
+        v = torch.randn(B, H, T, D, dtype=dtype)
+        w = torch.randn(H, D, dtype=dtype)
+        b = torch.randn(H, D, dtype=dtype)
+        eta = torch.randn(B, H, T, 1, dtype=dtype) * eta_base
+        h0 = torch.randn(B, H, D, D, dtype=torch.float32)
+        hb0 = torch.randn(B, H, 1, D, dtype=torch.float32)
+    else:
+        q = torch.randn(B, T, H, D, dtype=dtype)
+        k = F.normalize(torch.randn(B, T, H, D, dtype=torch.float32), p=2, dim=-1).to(dtype)
+        v = torch.randn(B, T, H, D, dtype=dtype)
+        w = torch.randn(H, D, dtype=dtype)
+        b = torch.randn(H, D, dtype=dtype)
+        eta = torch.randn(B, T, H, 1, dtype=dtype) * eta_base
+        h0 = torch.randn(B, H, D, D, dtype=torch.float32)
+        hb0 = torch.randn(B, H, 1, D, dtype=torch.float32)
+
+    q, k, v, w, b, eta, h0, hb0 = map(lambda x: x.to(device).requires_grad_(True), (q, k, v, w, b, eta, h0, hb0))
+    do = torch.rand_like(v)
+    dht = torch.rand_like(h0)
+    dhbt = torch.rand_like(hb0)
+
+    tri, tri_ht, tri_hbt = chunk_ttt_linear(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        w.clone(),
+        b.clone(),
+        eta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        initial_state_bias=hb0.clone(),
+        head_first=head_first
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum() + (tri_hbt * dhbt).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_dw, tri_db, tri_deta, \
+        tri_dh0, tri_dhb0 = q.grad, k.grad, v.grad, w.grad, b.grad, eta.grad, h0.grad, hb0.grad
+    q.grad = k.grad = v.grad = w.grad = b.grad = eta.grad = h0.grad = hb0.grad = None
+
+    ref, ref_ht, ref_hbt = chunk_ttt_linear_ref(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        w.clone(),
+        b.clone(),
+        eta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        initial_state_bias=hb0.clone(),
+        head_first=head_first
+    )
+    ((ref * do).sum() + (ref_ht * dht).sum() + (ref_hbt * dhbt).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_dw, ref_db, ref_deta, \
+        ref_dh0, ref_dhb0 = q.grad, k.grad, v.grad, w.grad, b.grad, eta.grad, h0.grad, hb0.grad
+
+    assert_close("   o", ref, tri, 0.005)
+    assert_close("  ht", ref_ht, tri_ht, 0.005)
+    assert_close(" hbt", ref_hbt, tri_hbt, 0.005)
+    assert_close("  dq", ref_dq, tri_dq, 0.005)
+    assert_close("  dk", ref_dk, tri_dk, 0.010)
+    assert_close("  dv", ref_dv, tri_dv, 0.007)
+    assert_close("  dw", ref_dw, tri_dw, 0.006)
+    assert_close("  db", ref_db, tri_db, 0.006)
+    assert_close("  de", ref_deta, tri_deta, 0.030)  # because the last element of the chunk
+    if head_first:
+        assert_close(" de0", ref_deta[:, :, :14, :], tri_deta[:, :, :14, :], 0.010)
+    else:
+        assert_close(" de0", ref_deta[:, :14, :, :], tri_deta[:, :14, :, :], 0.010)
+    assert_close(" dh0", ref_dh0, tri_dh0, 0.007)
+    assert_close("dhb0", ref_dhb0, tri_dhb0, 0.005)
+
+
+@pytest.mark.parametrize("B", test_b_list)
+@pytest.mark.parametrize("T", test_t_list)
+@pytest.mark.parametrize("H", test_h_list)
+@pytest.mark.parametrize("D", test_d_list)
+@pytest.mark.parametrize("scale", [0.1])
+@pytest.mark.parametrize("dtype", [torch.float16])
+@pytest.mark.parametrize("head_first", [True, False])
+@pytest.mark.skipif(
+    os.getenv("SKIP_TEST_CHUNK_VARLEN") == "0",
+    reason="Skipping test because TEST_CHUNK_VARLEN is enabled"
+)
+def test_fused_chunk_fwd(
+    B: int,
+    T: int,
+    H: int,
+    D: int,
+    dtype: torch.dtype,
+    scale: float,
+    head_first: bool
+):
+    if D > 64 and check_shared_mem('hopper') is False:
+        pytest.skip(reason="Current CI do not support this config")
+    eta_base = 5e-3
+    if head_first:
+        q = torch.randn(B, H, T, D, dtype=dtype)
+        k = F.normalize(torch.randn(B, H, T, D, dtype=torch.float32), p=2, dim=-1).to(dtype)
+        v = torch.randn(B, H, T, D, dtype=dtype)
+        w = torch.randn(H, D, dtype=dtype)
+        b = torch.randn(H, D, dtype=dtype)
+        eta = torch.randn(B, H, T, 1, dtype=dtype) * eta_base
+        h0 = torch.randn(B, H, D, D, dtype=torch.float32)
+        hb0 = torch.randn(B, H, 1, D, dtype=torch.float32)
+    else:
+        q = torch.randn(B, T, H, D, dtype=dtype)
+        k = F.normalize(torch.randn(B, T, H, D, dtype=torch.float32), p=2, dim=-1).to(dtype)
+        v = torch.randn(B, T, H, D, dtype=dtype)
+        w = torch.randn(H, D, dtype=dtype)
+        b = torch.randn(H, D, dtype=dtype)
+        eta = torch.randn(B, T, H, 1, dtype=dtype) * eta_base
+        h0 = torch.randn(B, H, D, D, dtype=torch.float32)
+        hb0 = torch.randn(B, H, 1, D, dtype=torch.float32)
+
+    q, k, v, w, b, eta, h0, hb0 = map(lambda x: x.to(device).requires_grad_(True), (q, k, v, w, b, eta, h0, hb0))
+    do = torch.rand_like(v)
+    dht = torch.rand_like(h0)
+    dhbt = torch.rand_like(hb0)
+
+    tri, tri_ht, tri_hbt = fused_chunk_ttt_linear(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        w.clone(),
+        b.clone(),
+        eta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        initial_state_bias=hb0.clone(),
+        head_first=head_first
+    )
+    ((tri * do).sum() + (tri_ht * dht).sum() + (tri_hbt * dhbt).sum()).backward(retain_graph=True)
+    tri_dq, tri_dk, tri_dv, tri_dw, tri_db, tri_deta, \
+        tri_dh0, tri_dhb0 = q.grad, k.grad, v.grad, w.grad, b.grad, eta.grad, h0.grad, hb0.grad
+    q.grad = k.grad = v.grad = w.grad = b.grad = eta.grad = h0.grad = hb0.grad = None
+
+    ref, ref_ht, ref_hbt = chunk_ttt_linear_ref(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        w.clone(),
+        b.clone(),
+        eta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        initial_state_bias=hb0.clone(),
+        head_first=head_first
+    )
+    ((ref * do).sum() + (ref_ht * dht).sum() + (ref_hbt * dhbt).sum()).backward(retain_graph=True)
+    ref_dq, ref_dk, ref_dv, ref_dw, ref_db, ref_deta, \
+        ref_dh0, ref_dhb0 = q.grad, k.grad, v.grad, w.grad, b.grad, eta.grad, h0.grad, hb0.grad
+
+    assert_close("   o", ref, tri, 0.005)
+    assert_close("  ht", ref_ht, tri_ht, 0.005)
+    assert_close(" hbt", ref_hbt, tri_hbt, 0.005)
+    assert_close("  dq", ref_dq, tri_dq, 0.005)
+    assert_close("  dk", ref_dk, tri_dk, 0.010)
+    assert_close("  dv", ref_dv, tri_dv, 0.007)
+    assert_close("  dw", ref_dw, tri_dw, 0.005)
+    assert_close("  db", ref_db, tri_db, 0.005)
+    assert_close("  de", ref_deta, tri_deta, 0.03)  # because the last element of the chunk
+    if head_first:
+        assert_close(" de0", ref_deta[:, :, :14, :], tri_deta[:, :, :14, :], 0.008)
+    else:
+        assert_close(" de0", ref_deta[:, :14, :, :], tri_deta[:, :14, :, :], 0.008)
+    assert_close(" dh0", ref_dh0, tri_dh0, 0.006)
+    assert_close("dhb0", ref_dhb0, tri_dhb0, 0.005)
+
+
+@pytest.mark.parametrize("N", test_b_list)
+@pytest.mark.parametrize("T", test_t_varlen_list)
+@pytest.mark.parametrize("H", test_h_list)
+@pytest.mark.parametrize("D", test_d_list)
+@pytest.mark.parametrize("scale", [0.1])
+@pytest.mark.parametrize("dtype", [torch.float16])
+@pytest.mark.skipif(
+    os.getenv("SKIP_TEST_CHUNK_VARLEN") == "1",
+    reason="Skipping test_chunk_varlen because SKIP_TEST_CHUNK_VARLEN is set"
+)
+def test_chunk_varlen_fwd(
+    N: int,
+    T: int,
+    H: int,
+    D: int,
+    scale: float,
+    dtype: torch.dtype,
+):
+    if D > 64 and check_shared_mem('hopper') is False:
+        pytest.skip(reason="Current CI do not support this config")
+    torch.manual_seed(42)
+    os.environ['TRITON_F32_DEFAULT'] = 'ieee'
+    # randomly split the sequence into N segments
+    offsets = torch.cat([
+        torch.tensor([0], dtype=torch.long),
+        torch.arange(16, T)[torch.randperm(T - 1)[:N-1]],
+        torch.tensor([T], dtype=torch.long)
+    ], 0).to(device).sort()[0]
+    eta_base = 5e-3
+    # seq-first required for inputs with variable lengths
+    q = torch.randn((1, T, H, D), dtype=dtype)
+    k = F.normalize(torch.randn(1, T, H, D, dtype=torch.float32), p=2, dim=-1).to(dtype)
+    v = torch.randn((1, T, H, D), dtype=dtype)
+    eta = torch.randn(1, T, H, 1, dtype=dtype) * eta_base
+    w = torch.randn(H, D, dtype=dtype)
+    b = torch.randn(H, D, dtype=dtype)
+    h0 = torch.randn((N, H, D, D), dtype=torch.float32)
+    hb0 = torch.randn((N, H, 1, D), dtype=torch.float32)
+    q, k, v, w, b, eta, h0, hb0 = map(lambda x: x.to(device).requires_grad_(), (q, k, v, w, b, eta, h0, hb0))
+
+    tri, tri_ht, tri_hbt = chunk_ttt_linear(
+        q.clone(),
+        k.clone(),
+        v.clone(),
+        w.clone(),
+        b.clone(),
+        eta.clone(),
+        scale=scale,
+        output_final_state=True,
+        initial_state=h0.clone(),
+        initial_state_bias=hb0.clone(),
+        cu_seqlens=offsets,
+        head_first=False
+    )
+
+    ref = []
+    ref_ht = []
+    ref_hbt = []
+    for i in range(N):
+        ref_i, ref_ht_i, ref_hbt_i = chunk_ttt_linear_ref(
+            q=q[:, offsets[i]:offsets[i+1]],
+            k=k[:, offsets[i]:offsets[i+1]],
+            v=v[:, offsets[i]:offsets[i+1]],
+            w=w,
+            b=b,
+            eta=eta[:, offsets[i]:offsets[i+1]],
+            scale=scale,
+            initial_state=h0[i],
+            initial_state_bias=hb0[i],
+            output_final_state=True,
+            head_first=False
+        )
+        ref.append(ref_i)
+        ref_ht.append(ref_ht_i)
+        ref_hbt.append(ref_hbt_i)
+    ref = torch.cat(ref, 1)
+    ref_ht = torch.cat(ref_ht, 0)
+    ref_hbt = torch.cat(ref_hbt, 0)
+
+    assert_close("  o", ref, tri, 0.005)
+    assert_close(" ht", ref_ht, tri_ht, 0.005)
+    assert_close("hbt", ref_hbt, tri_hbt, 0.005)