Add files using upload-large-folder tool

REGEN-main/cosmos_policy/_src/imaginaire/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+

REGEN-main/cosmos_policy/_src/imaginaire/attention/README.md

@@ -0,0 +1,47 @@
+# Imaginaire Attention Subpackage
+
+A subpackage within cosmos_policy._src.imaginaire that integrates only the best and most reliable
+solutions, and provides simple APIs to end-users.
+
+For more information, please refer to the [docs](docs/).
+
+## Basic API
+
+```python
+from cosmos_policy._src.imaginaire.attention import attention
+
+output = attention(
+    query=query,
+    key=key,
+    value=value,
+)
+```
+
+* **Optional** `scale`: attention (softmax/dot product) scale. Defaults to `head_dim ** -0.5`.
+* **Optional** `return_lse`: returns logsumexp if `True`
+* **Optional** `backend`: explicitly set backend instead of automatically selecting the best compatible
+
+## Tensor layouts
+
+Imaginaire Attention only supports one tensor memory layout:
+heads-last torch contiguous (`torch.contiguous_format`).
+
+With this layout, input tensors `query`, `key`, and `value` are represented as rank-4 tensors, with
+dimension 0 representing batch, dimension 1 representing sequence length, dimension 2 representing
+attention heads, and dimension 3 representing head dimension.
+This layout is also consistent with the `contiguous_format` memory layout in PyTorch, meaning the
+right-most dimension (head dimension) is the major dimension (has stride 1), and tokens from
+different heads are interleaved.
+
+```python
+def verify_heads_last_contig_tensor(x: Tensor):
+    assert x.shape[0] == batch
+    assert x.shape[1] == seqlen
+    assert x.shape[2] == heads
+    assert x.shape[3] == head_dim
+
+    assert x.stride(3) == 1
+    assert x.stride(2) == head_dim
+    assert x.stride(1) == heads * head_dim
+    assert x.stride(0) == heads * head_dim * seqlen
+```

REGEN-main/cosmos_policy/_src/imaginaire/attention/__init__.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+
+"""
+
+from cosmos_policy._src.imaginaire.attention.frontend import (
+    attention,
+    multi_dimensional_attention,
+    spatio_temporal_attention,
+)
+
+__all__ = ["attention", "multi_dimensional_attention", "spatio_temporal_attention"]

REGEN-main/cosmos_policy/_src/imaginaire/attention/backends.py

@@ -0,0 +1,348 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Frontend APIs
+"""
+
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.cudnn.checks import cudnn_attention_check
+from cosmos_policy._src.imaginaire.attention.flash2.checks import flash2_attention_check
+from cosmos_policy._src.imaginaire.attention.flash3.checks import flash3_attention_check
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.natten.checks import (
+    natten_attention_check,
+    natten_multi_dim_attention_check,
+)
+from cosmos_policy._src.imaginaire.attention.utils import get_arch_tag
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+BACKEND_CHECK_MAP = {
+    "cudnn": cudnn_attention_check,
+    "natten": natten_attention_check,
+    "flash2": flash2_attention_check,
+    "flash3": flash3_attention_check,
+}
+
+BACKEND_MULTI_DIM_CHECK_MAP = {
+    "natten": natten_multi_dim_attention_check,
+}
+
+
+def is_backend_compatible(
+    backend: str,
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool,
+    causal_type: CausalType | None,
+    is_varlen: bool,
+    raise_error: bool = False,
+) -> bool:
+    """
+    Input validation function a specified backend.
+    Runs the common and backend-specific checks. Returns False if any checks fail, otherwise True.
+
+    Parameters:
+        backend (str): selected backend.
+
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`).
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`).
+
+        is_causal (bool): whether or not causal masking is enabled.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`. Required when `is_causal = True`.
+
+        is_varlen (bool): whether or not a variable length (varlen) use case. Must be inferred
+            beforehand based on arguments such as seqlens_{Q,KV} or cumulative_seqlen_{Q,KV} being
+            passed.
+
+        raise_error (bool): whether to raise an error if any checks fail or no backend is selected,
+            instead of just returning False. Default is False.
+
+    Returns:
+        success (bool): whether use case is compatible with the backend.
+
+    """
+    if backend is None:
+        raise ValueError("Cannot pass None backend to is_backend_compatible.")
+
+    if backend not in BACKEND_CHECK_MAP:
+        raise ValueError(f"Unrecognized backend name {backend}.")
+
+    return BACKEND_CHECK_MAP[backend](
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+        is_varlen=is_varlen,
+        raise_error=raise_error,
+    )
+
+
+def get_backend_list(arch_tag: int) -> list[str]:
+    """
+    Returns list of supported backends according to arch tag (attention.utils.get_arch_tag).
+    Backends are ordered based on their known performance levels, so that the best-performing
+    compatible backend is selected.
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        backend_list (list[str]): a list of backend names (string). Empty if device is not supported.
+
+    """
+
+    if arch_tag < 75:
+        log.debug(f"Minimum architecture supported for Attention is 75, got {arch_tag=}.")
+        return []
+
+    if arch_tag == 90:
+        return [
+            "flash3",
+            "cudnn",
+            "natten",
+            "flash2",
+        ]
+
+    if arch_tag in [100, 103]:
+        return [
+            # "flash4",
+            "cudnn",
+            "natten",
+            "flash2",
+        ]
+
+    if arch_tag >= 80:
+        return [
+            "flash2",
+            "cudnn",
+            "natten",
+        ]
+
+    return ["natten"]
+
+
+def choose_backend(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool,
+    causal_type: CausalType | None,
+    is_varlen: bool,
+    backend: str | None = None,
+    raise_error: bool = True,
+) -> str | None:
+    """
+    Selects a compatible backend, unless one is already selected, which runs its corresponding
+    checks.
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`).
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`).
+
+        is_causal (bool): whether or not causal masking is enabled.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`. Required when `is_causal = True`.
+
+        is_varlen (bool): whether or not a variable length (varlen) use case. Must be inferred
+            beforehand based on arguments such as seqlens_{Q,KV} or cumulative_seqlen_{Q,KV} being
+            passed.
+
+        backend (str | None): selected backend, if any.
+
+        raise_error (bool): whether to raise an error if any checks fail or no backend is selected,
+            instead of just returning False. Default is **True**.
+
+    Returns:
+        backend (str | None): selected backend, or None if no backends are compatible.
+
+    """
+    if backend is not None:
+        if is_backend_compatible(
+            backend=backend,
+            query=query,
+            key=key,
+            value=value,
+            is_causal=is_causal,
+            causal_type=causal_type,
+            is_varlen=is_varlen,
+            raise_error=raise_error,
+        ):
+            return backend
+        return None
+
+    arch_tag = get_arch_tag(query.device)
+    backend_list = get_backend_list(arch_tag)
+    for backend in backend_list:
+        if is_backend_compatible(
+            backend=backend,
+            query=query,
+            key=key,
+            value=value,
+            is_causal=is_causal,
+            causal_type=causal_type,
+            is_varlen=is_varlen,
+            raise_error=False,
+        ):
+            return backend
+
+    if not raise_error:
+        return None
+
+    raise ValueError(
+        "Could not find a compatible Attention backend for this use case / device. "
+        "Try running with debug logs to find out why."
+    )
+
+
+def is_multi_dim_backend_compatible(
+    backend: str,
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    raise_error: bool = False,
+) -> bool:
+    """
+    Input validation function a specified multi-dimensional backend.
+    Runs the common and backend-specific checks. Returns False if any checks fail, otherwise True.
+
+    Parameters:
+        backend (str): selected backend.
+
+        query (Tensor): 4-D, 5-D, or 6-D query tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads, head_dim]`).
+
+        key (Tensor): 4-D, 5-D, or 6-D key tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D, 5-D, or 6-D value tensor, with heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim_v]`).
+
+        raise_error (bool): whether to raise an error if any checks fail or no backend is selected,
+            instead of just returning False. Default is False.
+
+    Returns:
+        success (bool): whether use case is compatible with the backend.
+
+    """
+    if backend is None:
+        raise ValueError("Cannot pass None backend to is_backend_compatible.")
+
+    if backend not in BACKEND_MULTI_DIM_CHECK_MAP:
+        raise ValueError(f"Unrecognized backend name {backend}.")
+
+    return BACKEND_MULTI_DIM_CHECK_MAP[backend](
+        query=query,
+        key=key,
+        value=value,
+        raise_error=raise_error,
+    )
+
+
+def get_multi_dim_backend_list(arch_tag: int) -> list[str]:
+    """
+    Returns list of supported multi-dimensional backends according to arch tag (attention.utils.get_arch_tag).
+    Backends are ordered based on their known performance levels, so that the best-performing
+    compatible backend is selected.
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        backend_list (list[str]): a list of backend names (string). Empty if device is not supported.
+
+    """
+
+    if arch_tag < 75:
+        log.debug(f"Minimum architecture supported for Multi-Dimensional Attention is 75, got {arch_tag=}.")
+        return []
+
+    # NATTEN is the only supported backend for now
+    return ["natten"]
+
+
+def choose_multi_dim_backend(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    backend: str | None = None,
+) -> str:
+    """
+    Selects a compatible multi-dimensional backend, unless one is already selected, which runs its
+    corresponding checks.
+
+    Parameters:
+        query (Tensor): 4-D, 5-D, or 6-D query tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads, head_dim]`).
+
+        key (Tensor): 4-D, 5-D, or 6-D key tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D, 5-D, or 6-D value tensor, with heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim_v]`).
+
+        backend (str | None): selected backend, if any.
+
+    Returns:
+        backend (str): selected backend.
+
+    """
+    if backend is not None:
+        assert is_multi_dim_backend_compatible(
+            backend=backend,
+            query=query,
+            key=key,
+            value=value,
+            raise_error=True,
+        )
+        return backend
+
+    arch_tag = get_arch_tag(query.device)
+    backend_list = get_multi_dim_backend_list(arch_tag)
+    for backend in backend_list:
+        if is_multi_dim_backend_compatible(
+            backend=backend,
+            query=query,
+            key=key,
+            value=value,
+            raise_error=False,
+        ):
+            return backend
+
+    raise ValueError(
+        "Could not find a compatible Multi-Dimensional Attention backend for this use case / device. "
+        "Try running with debug logs to find out why."
+    )

REGEN-main/cosmos_policy/_src/imaginaire/attention/checks.py

@@ -0,0 +1,500 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Common, op-specific, and backend-specific checks
+"""
+
+from collections.abc import Sequence
+from functools import partial
+from typing import Any
+
+import torch
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.utils import log_or_raise_error
+from cosmos_policy._src.imaginaire.attention.varlen import generate_varlen_parameters
+
+
+def _universal_tensor_checks(query: Tensor, key: Tensor, value: Tensor, raise_error: bool = True) -> bool:
+    target_fn = partial(log_or_raise_error, raise_error=raise_error)
+
+    if query.is_sparse or key.is_sparse or value.is_sparse:
+        target_fn("This operation does not support sparse tensors.", exception=NotImplementedError)
+        return False
+
+    if query.is_nested or key.is_nested or value.is_nested:
+        target_fn("This operation does not support nested tensors.", exception=NotImplementedError)
+        return False
+
+    if query.device != key.device or query.device != value.device:
+        target_fn(
+            f"Query, key, and value must be on the same device, got {query.device=}, {key.device=}, {value.device=}.",
+            exception=ValueError,
+        )
+        return False
+
+    if query.dtype != key.dtype or query.dtype != value.dtype:
+        target_fn(
+            f"Query, key, and value must assume the same data type, got {query.dtype=}, {key.dtype=}, {value.dtype=}.",
+            exception=ValueError,
+        )
+        return False
+
+    return True
+
+
+def _universal_attention_checks(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    supported_dtypes_forward: list[torch.dtype] | None = None,
+    supported_dtypes_backward: list[torch.dtype] | None = None,
+    supports_mla: bool = True,
+    supports_gqa_mqa: bool = True,
+    raise_error: bool = True,
+    backend_name: str | None = None,
+) -> bool:
+    backend_name = backend_name or "Attention"
+    if not _universal_tensor_checks(query, key, value, raise_error=raise_error):
+        return False
+
+    target_fn = partial(log_or_raise_error, raise_error=raise_error)
+
+    if query.dim() != key.dim() or query.dim() != value.dim():
+        target_fn(
+            f"Q, K, and V must have the same rank, got {query.dim()=}, {key.dim()=}, {value.dim()=}.",
+            exception=ValueError,
+        )
+        return False
+
+    if query.shape[0] != key.shape[0] or query.shape[0] != value.shape[0]:
+        target_fn(
+            f"Q, K, and V must match in batch size, got {query.shape[0]=}, {key.shape[0]=}, {value.shape[0]=}.",
+            exception=ValueError,
+        )
+        return False
+
+    if query.shape[-1] != key.shape[-1]:
+        target_fn(
+            f"Q and K head dims must match, got {query.shape[-1]=}, {key.shape[-1]=}.",
+            exception=ValueError,
+        )
+        return False
+
+    if key.shape[-2] != value.shape[-2]:
+        target_fn(
+            f"K and V must always have the same number of heads, got {key.shape[2]=}, {value.shape[2]=}.",
+            exception=ValueError,
+        )
+        return False
+
+    if not supports_mla and query.shape[-1] != value.shape[-1]:
+        target_fn(
+            f"{backend_name} does not support different head dims for QK and V, got "
+            f"{query.shape[-1]=}, {value.shape[-1]=}.",
+            exception=ValueError,
+        )
+        return False
+
+    if not supports_gqa_mqa and (query.shape[-2] != key.shape[-2] or query.shape[-2] != value.shape[-2]):
+        target_fn(
+            f"{backend_name} does not support GQA/MQA, therefore number of heads in Q, K, and V "
+            f"must match, got {query.shape[-2]=}, {key.shape[-2]=}, {value.shape[-2]=}.",
+            exception=ValueError,
+        )
+        return False
+
+    if supports_gqa_mqa:
+        heads_q = query.shape[-2]
+        heads_kv = key.shape[-2]
+
+        if heads_q < heads_kv or heads_q % heads_kv != 0:
+            target_fn(
+                f"KV heads must evenly divide Q heads, got {heads_q=}, {heads_kv=}.",
+                exception=ValueError,
+            )
+            return False
+
+    # _universal_tensor_checks guarantees query.dtype == key.dtype == value.dtype
+    if supported_dtypes_forward is not None and query.dtype not in supported_dtypes_forward:
+        target_fn(
+            f"{backend_name} does not support forward pass (inference) with data type {query.dtype}; "
+            f"supported dtypes: {supported_dtypes_forward}.",
+            exception=ValueError,
+        )
+        return False
+
+    if supported_dtypes_backward is not None and query.requires_grad and query.dtype not in supported_dtypes_backward:
+        target_fn(
+            f"{backend_name} does not support backward pass (training) with data type {query.dtype}; "
+            f"supported dtypes: {supported_dtypes_backward}.",
+            exception=ValueError,
+        )
+        return False
+
+    return True
+
+
+def attention_tensor_checks(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    supported_dtypes_forward: list[torch.dtype] | None = None,
+    supported_dtypes_backward: list[torch.dtype] | None = None,
+    supports_mla: bool = True,
+    supports_gqa_mqa: bool = True,
+    raise_error: bool = True,
+    backend_name: str | None = None,
+) -> bool:
+    backend_name = backend_name or "Attention"
+    if not _universal_tensor_checks(query, key, value, raise_error=raise_error):
+        return False
+
+    if not _universal_attention_checks(
+        query=query,
+        key=key,
+        value=value,
+        supported_dtypes_forward=supported_dtypes_forward,
+        supported_dtypes_backward=supported_dtypes_backward,
+        supports_mla=supports_mla,
+        supports_gqa_mqa=supports_gqa_mqa,
+        raise_error=raise_error,
+        backend_name=backend_name,
+    ):
+        return False
+
+    target_fn = partial(log_or_raise_error, raise_error=raise_error)
+
+    if query.dim() != 4:
+        target_fn(
+            f"Attention expects 4-D tensors as inputs, got {query.dim()=}.",
+            exception=ValueError,
+        )
+        return False
+
+    if key.shape[1] != value.shape[1]:
+        target_fn(
+            f"K and V must match in sequence length, got {key.shape[1]=}, {value.shape[1]=}.",
+            exception=ValueError,
+        )
+        return False
+
+    return True
+
+
+def varlen_tensor_checks(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    seqlens_Q: Tensor | None = None,
+    seqlens_KV: Tensor | None = None,
+    cumulative_seqlen_Q: Tensor | None = None,
+    cumulative_seqlen_KV: Tensor | None = None,
+    max_seqlen_Q: int | None = None,
+    max_seqlen_KV: int | None = None,
+) -> tuple[None, None, int, int] | tuple[Tensor, Tensor, int, int]:
+    if query.shape[0] != key.shape[0] or query.shape[0] != value.shape[0]:
+        raise ValueError(
+            f"Q, K, and V must match in batch size, got {query.shape[0]=}, {key.shape[0]=}, {value.shape[0]=}."
+        )
+
+    if all(
+        x is None
+        for x in [
+            seqlens_Q,
+            seqlens_KV,
+            cumulative_seqlen_Q,
+            cumulative_seqlen_KV,
+        ]
+    ) and all(
+        x is None or x == 0
+        for x in [
+            max_seqlen_Q,
+            max_seqlen_KV,
+        ]
+    ):
+        # Not varlen
+        return None, None, 0, 0
+
+    if seqlens_Q is not None or seqlens_KV is not None:
+        # Generate cumulative_seqlen_{Q,KV}, max_seqlen_{Q,KV}, total_seqlen_{Q,KV}
+        # based on user input
+        return generate_varlen_parameters(
+            query=query,
+            key=key,
+            value=value,
+            seqlens_Q=seqlens_Q,
+            seqlens_KV=seqlens_KV,
+        )
+
+    # Validate user-input cumulative_seqlen_{Q,KV}, max_seqlen_{Q,KV}, total_seqlen_{Q,KV}
+    if any(
+        x is None
+        for x in [
+            cumulative_seqlen_Q,
+            cumulative_seqlen_KV,
+            max_seqlen_Q,
+            max_seqlen_KV,
+        ]
+    ) or any(
+        x == 0
+        for x in [
+            max_seqlen_Q,
+            max_seqlen_KV,
+        ]
+    ):
+        raise ValueError(
+            "Variable length Attention requires all 6 of "
+            "cumulative_seqlen_{Q,KV}, max_seqlen_{Q,KV}, total_seqlen_{Q,KV} to be set."
+        )
+
+    if query.shape[0] != 1:
+        raise ValueError(
+            f"Variable length Attention only supports sequence-packed memory layout (batch = 1), got {query.shape[0]=}."
+        )
+
+    assert cumulative_seqlen_Q is not None
+    assert cumulative_seqlen_KV is not None
+    assert max_seqlen_Q is not None
+    assert max_seqlen_KV is not None
+
+    if not isinstance(max_seqlen_Q, int) or not isinstance(max_seqlen_KV, int):
+        raise ValueError(
+            f"max_seqlen_Q and max_seqlen_KV must be ints, got {type(max_seqlen_Q)=}, {type(max_seqlen_KV)=}."
+        )
+
+    total_seqlen_Q = query.shape[1]
+    total_seqlen_KV = key.shape[1]
+    if max_seqlen_Q > total_seqlen_Q:
+        raise ValueError(f"Maximum sequence length cannot exceed total, got {max_seqlen_Q=}, {total_seqlen_Q=}.")
+
+    if max_seqlen_KV > total_seqlen_KV:
+        raise ValueError(f"Maximum sequence length cannot exceed total, got {max_seqlen_KV=}, {total_seqlen_KV=}.")
+
+    if max_seqlen_Q < 1 or max_seqlen_KV < 1:
+        raise ValueError(f"Maximum sequence length cannot be less than 1, got {max_seqlen_Q=}, {max_seqlen_KV=}.")
+
+    if not isinstance(cumulative_seqlen_Q, Tensor) or not isinstance(cumulative_seqlen_KV, Tensor):
+        raise ValueError("cumulative_seqlen_Q and cumulative_seqlen_KV must both be tensors.")
+
+    if cumulative_seqlen_Q.device != query.device or cumulative_seqlen_KV.device != query.device:
+        raise ValueError(
+            "cumulative_seqlen_Q and cumulative_seqlen_KV must be on the same device as QKV, but "
+            f"{cumulative_seqlen_Q.device=}, {cumulative_seqlen_KV.device=}, {query.device=}."
+        )
+
+    if cumulative_seqlen_Q.dtype != torch.int32 or cumulative_seqlen_KV.dtype != torch.int32:
+        raise ValueError(
+            "cumulative_seqlen_Q and cumulative_seqlen_KV must both be torch.int32 tensors, got "
+            f"{cumulative_seqlen_Q.dtype=}, {cumulative_seqlen_KV.dtype=}."
+        )
+
+    if cumulative_seqlen_Q.dim() != 1 or cumulative_seqlen_KV.dim() != 1:
+        raise ValueError(
+            "cumulative_seqlen_Q and cumulative_seqlen_KV must both be 1-D tensors, got "
+            f"{cumulative_seqlen_Q.dim()=}, {cumulative_seqlen_KV.dim()=}."
+        )
+
+    if cumulative_seqlen_Q.shape[0] != cumulative_seqlen_KV.shape[0]:
+        raise ValueError(
+            "cumulative_seqlen_Q and cumulative_seqlen_KV must match in size, got "
+            f"{cumulative_seqlen_Q.shape=}, {cumulative_seqlen_KV.shape=}."
+        )
+
+    if cumulative_seqlen_Q.shape[0] < 2:
+        raise ValueError(
+            "cumulative_seqlen_Q and cumulative_seqlen_KV must contain at least 2 elements, got "
+            f"{cumulative_seqlen_Q.shape=}, {cumulative_seqlen_KV.shape=}."
+        )
+
+    return (
+        cumulative_seqlen_Q,
+        cumulative_seqlen_KV,
+        max_seqlen_Q,
+        max_seqlen_KV,
+    )
+
+
+def attention_param_checks(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool,
+    causal_type: CausalType,
+):
+    if is_causal and (causal_type is None or not isinstance(causal_type, CausalType)):
+        raise ValueError(
+            f"Argument causal_type must be specified as an enum instance of CausalType when is_causal=True, got {causal_type=}."
+        )
+
+    assert query.dim() == key.dim() == value.dim() == 4
+    assert key.shape[1] == value.shape[1]
+    if is_causal and causal_type == CausalType.DontCare and query.shape[1] != key.shape[1]:
+        raise ValueError(
+            "Causal mask type DontCare is only valid when seqlen_q == seqlen_kv, got "
+            f"{query.shape[1]=}, {key.shape[1]=}."
+        )
+
+
+def multi_dim_attention_tensor_checks(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    supported_dtypes_forward: list[torch.dtype] | None = None,
+    supported_dtypes_backward: list[torch.dtype] | None = None,
+    supports_mla: bool = True,
+    supports_gqa_mqa: bool = True,
+    raise_error: bool = True,
+    backend_name: str | None = None,
+) -> bool:
+    backend_name = backend_name or "Multi-Dimensional Attention"
+    if not _universal_tensor_checks(query, key, value, raise_error=raise_error):
+        return False
+
+    if not _universal_attention_checks(
+        query=query,
+        key=key,
+        value=value,
+        supported_dtypes_forward=supported_dtypes_forward,
+        supported_dtypes_backward=supported_dtypes_backward,
+        supports_mla=supports_mla,
+        supports_gqa_mqa=supports_gqa_mqa,
+        raise_error=raise_error,
+        backend_name=backend_name,
+    ):
+        return False
+
+    target_fn = partial(log_or_raise_error, raise_error=raise_error)
+
+    if query.dim() not in [4, 5, 6]:
+        target_fn(
+            f"Multi-Dimensional Attention supports 4-D, 5-D, or 6-D tensors as inputs, got {query.dim()=}.",
+            exception=ValueError,
+        )
+        return False
+
+    num_dims = query.dim() - 3  # minus batch, heads, head_dim
+
+    q_token_layout_shape = query.shape[1 : 1 + num_dims]
+    k_token_layout_shape = key.shape[1 : 1 + num_dims]
+    v_token_layout_shape = value.shape[1 : 1 + num_dims]
+
+    if q_token_layout_shape != k_token_layout_shape or q_token_layout_shape != v_token_layout_shape:
+        target_fn(
+            "Q, K and V must match in their token layout shapes in multi-dimensional attention, "
+            f"got {q_token_layout_shape=}, {k_token_layout_shape=}, {v_token_layout_shape=}.",
+            exception=ValueError,
+        )
+        return False
+
+    return True
+
+
+def check_valid_tuple_or_element(param: Any, num_dims: int, typename: type) -> tuple | None:
+    if isinstance(param, typename):
+        return tuple(param for _ in range(num_dims))
+
+    if isinstance(param, Sequence) and len(param) == num_dims and all(isinstance(x, typename) for x in param):
+        return param
+
+    return None
+
+
+def multi_dim_attention_param_filter(
+    query: Tensor,
+    window_size: tuple | int = -1,
+    stride: tuple | int = 1,
+    dilation: tuple | int = 1,
+    is_causal: tuple | bool = False,
+) -> tuple[tuple, tuple, tuple, tuple, tuple, tuple]:
+    """
+    Converts all multi-dimensional parameters to standard types.
+    """
+    assert query.dim() in [4, 5, 6]
+    num_dims = query.dim() - 3
+
+    token_layout_shape = tuple(s for s in query.shape[1 : 1 + num_dims])
+
+    window_size_ = check_valid_tuple_or_element(window_size, num_dims, int)
+    if window_size_ is None:
+        raise ValueError(
+            f"Parameter 'window_size' must be either an int or tuple of {num_dims} ints, got {window_size=}."
+        )
+
+    stride_ = check_valid_tuple_or_element(stride, num_dims, int)
+    if stride_ is None:
+        raise ValueError(f"Parameter 'stride' must be either an int or tuple of {num_dims} ints, got {stride=}.")
+
+    dilation_ = check_valid_tuple_or_element(dilation, num_dims, int)
+    if dilation_ is None:
+        raise ValueError(f"Parameter 'dilation' must be either an int or tuple of {num_dims} ints, got {dilation=}.")
+
+    is_causal_ = check_valid_tuple_or_element(is_causal, num_dims, bool)
+    if is_causal_ is None:
+        raise ValueError(
+            f"Parameter 'is_causal' must be either a boolean or tuple of {num_dims} booleans, got {is_causal=}."
+        )
+
+    # Map -1 windows to corresponding size in token layout
+    window_size_ = tuple(w if w != -1 else x for x, w in zip(token_layout_shape, window_size_))
+
+    return token_layout_shape, window_size_, stride_, dilation_, is_causal_
+
+
+def multi_dim_attention_param_checks(
+    query: Tensor,
+    window_size: tuple,
+    stride: tuple,
+    dilation: tuple,
+    is_causal: tuple,
+):
+    """
+    Validates multi-dimensional parameters.
+    """
+    assert query.dim() in [4, 5, 6]
+    num_dims = query.dim() - 3
+
+    token_layout_shape = tuple(s for s in query.shape[1 : 1 + num_dims])
+
+    if any(x <= 1 for x in token_layout_shape):
+        raise ValueError(f"Token layout dimensions must all be >= 2, got {token_layout_shape=} ({query.shape=}).")
+
+    if any(w <= 1 for w in window_size):
+        raise ValueError(
+            "Parameter 'window_size' must be either -1 (no sparsity) or >= 2 along every dimension, "
+            f"got {window_size=}."
+        )
+
+    if any(w * d > x for x, w, d in zip(token_layout_shape, window_size, dilation)):
+        raise ValueError(
+            "The product of 'window_size' and 'dilation' cannot be greater than the input "
+            f"(token layout shape), got {window_size=}, {dilation=}, {token_layout_shape=} ({query.shape=})."
+        )
+
+    if any(s < 1 for s in stride):
+        raise ValueError(f"Parameter 'stride' allows positive integers only, got {stride=}.")
+
+    if any(s > w for w, s in zip(window_size, stride)):
+        raise ValueError(
+            f"Parameter 'stride' cannot be greater than window size along any dimension, got {window_size=}, {stride=}."
+        )
+
+    if any(d < 1 for d in dilation):
+        raise ValueError(f"Parameter 'dilation' allows positive integers only, got {dilation=}.")

REGEN-main/cosmos_policy/_src/imaginaire/attention/cudnn/__init__.py

@@ -0,0 +1,97 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+cuDNN Backend
+"""
+
+import torch
+
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+# (ahassani) [11-20-2025] Banning cuDNN until reliability issues are resolved.
+# Versions checked: 91300, 91400, 91500
+# (ahassani) [12-01-2025]
+# 91500 ran on both GB200 and H100 SXM.
+CUDNN_DISALLOWED = True
+
+CUDNN_MIN_BACKEND_VERSION = 91300
+CUDNN_MIN_FRONTEND_VERSION = [1, 14, 0]
+
+
+def cudnn_supported() -> bool:
+    """
+    Returns whether cuDNN Attention is supported in this environment.
+    Requirements are:
+        * Presence of CUDA Runtime (via PyTorch)
+        * Presence of cuDNN and its Python frontend, meeting minimum version requirements
+
+    This check guards imports / dependencies on the cuDNN package.
+    """
+    if not torch.cuda.is_available():
+        log.debug("cuDNN Attention is not supported because PyTorch did not detect CUDA runtime.")
+        return False
+
+    try:
+        import cudnn
+
+    except ImportError:
+        log.debug("cuDNN Attention is not supported because the frontend Python package was not found.")
+        return False
+    except Exception as e:
+        log.debug(f"cuDNN Attention is not supported because importing the frontend Python package failed: {e}")
+        return False
+
+    if cudnn.backend_version() < CUDNN_MIN_BACKEND_VERSION:
+        log.debug(
+            "cuDNN Attention is not supported due to insufficient cuDNN backend version "
+            f"{cudnn.backend_version()=}, expected at least {CUDNN_MIN_BACKEND_VERSION=}."
+        )
+        return False
+
+    cudnn_frontend_version_split = cudnn.__version__.split(".")
+    if len(cudnn_frontend_version_split) != 3:
+        log.debug(f"Unable to parse cuDNN frontend version {cudnn.__version__}.")
+        return False
+
+    try:
+        cudnn_frontend_version = [int(x) for x in cudnn_frontend_version_split]
+    except ValueError:
+        log.debug(f"Unable to parse cuDNN frontend version as an int list: {cudnn.__version__}.")
+        return False
+
+    if cudnn_frontend_version < CUDNN_MIN_FRONTEND_VERSION:
+        log.debug(
+            "cuDNN Attention is not supported due to insufficient cuDNN frontend version "
+            f"{cudnn_frontend_version=}, expected at least {CUDNN_MIN_FRONTEND_VERSION=}."
+        )
+        return False
+
+    return True
+
+
+CUDNN_SUPPORTED = cudnn_supported()
+
+
+if CUDNN_SUPPORTED:
+    from cosmos_policy._src.imaginaire.attention.cudnn.functions import cudnn_attention
+
+else:
+    from cosmos_policy._src.imaginaire.attention.cudnn.stubs import cudnn_attention
+
+__all__ = ["cudnn_attention", "CUDNN_SUPPORTED"]

REGEN-main/cosmos_policy/_src/imaginaire/attention/cudnn/checks.py

@@ -0,0 +1,128 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+cudNN backend checks
+"""
+
+from functools import partial
+
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.checks import attention_param_checks, attention_tensor_checks
+from cosmos_policy._src.imaginaire.attention.cudnn import CUDNN_DISALLOWED, CUDNN_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.cudnn.meta import get_bwd_dtypes, get_fwd_dtypes
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.utils import get_arch_tag, is_torch_compiling, log_or_raise_error
+
+
+def cudnn_attention_check(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool,
+    causal_type: CausalType,
+    is_varlen: bool,
+    raise_error: bool = False,
+) -> bool:
+    """
+    Input validation function for the cuDNN backend.
+    Runs the common and cuDNN-specific checks. Returns False if any checks fail, otherwise True.
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`).
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`).
+
+        is_causal (bool): whether or not causal masking is enabled.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`. Required when `is_causal = True`.
+
+        is_varlen (bool): whether or not a variable length (varlen) use case. Must be inferred
+            beforehand based on arguments such as seqlens_{Q,KV} or cumulative_seqlen_{Q,KV} being
+            passed.
+
+        raise_error (bool): whether to raise an error if any checks fail or no backend is selected,
+            instead of just returning False. Default is False.
+
+    Returns:
+        success (bool): whether use case is compatible with cuDNN backend.
+
+    """
+    target_fn = partial(log_or_raise_error, raise_error=raise_error)
+
+    if not CUDNN_SUPPORTED:
+        target_fn(
+            "cuDNN is not supported in this environment. Run with debug logs to find out why, or choose another backend.",
+            exception=RuntimeError,
+        )
+        return False
+
+    if CUDNN_DISALLOWED:
+        target_fn("cuDNN backend is disabled. Please choose another backend.", exception=RuntimeError)
+        return False
+
+    if is_torch_compiling():
+        target_fn(
+            "cuDNN backend does not support torch.compile yet.",
+            exception=RuntimeError,
+        )
+        return False
+
+    arch_tag = get_arch_tag(query.device)
+    fwd_dtypes = get_fwd_dtypes(arch_tag)
+    bwd_dtypes = get_bwd_dtypes(arch_tag)
+    if not attention_tensor_checks(
+        query=query,
+        key=key,
+        value=value,
+        supported_dtypes_forward=fwd_dtypes,
+        supported_dtypes_backward=bwd_dtypes,
+        supports_mla=False,
+        supports_gqa_mqa=False,
+        raise_error=raise_error,
+        backend_name="cuDNN Attention",
+    ):
+        target_fn("cuDNN does not support the given inputs.", exception=RuntimeError)
+        return False
+
+    if is_varlen:
+        target_fn("Varlen for cuDNN Attention is not integrated yet.", exception=RuntimeError)
+        return False
+
+    # Verifies causal_type is a CausalType instance when is_causal
+    # Verifies DontCare is not used unless seqlen_q == seqlen_kv
+    attention_param_checks(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+    )
+
+    if is_causal and causal_type not in [CausalType.TopLeft, CausalType.DontCare]:
+        target_fn("cuDNN Attention only supports top-left causal masking for now.", exception=RuntimeError)
+        return False
+
+    return True

REGEN-main/cosmos_policy/_src/imaginaire/attention/cudnn/cudnn_forward.py

@@ -0,0 +1,411 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+cuDNN Backend: intermediate APIs
+Only safe to import when CUDNN_SUPPORTED is True.
+"""
+
+from functools import lru_cache
+from typing import Callable
+
+import cudnn
+import torch
+from torch import Size, Tensor
+
+from cosmos_policy._src.imaginaire.attention.utils import get_arch_tag
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+# Force using padded mask as a potential workaround for failing use cases
+FORCE_PADDED_MASK = False
+
+CUDNN_GRAPH_CACHE_SIZE = 64
+
+log.debug(f"cuDNN Attention graphs are cached using an LRU cache with capacity {CUDNN_GRAPH_CACHE_SIZE}.")
+log.debug(f"cuDNN Attention {FORCE_PADDED_MASK=}.")
+
+
+def get_dtype_choices(arch_tag: int) -> dict:
+    """
+    Returns data type choices according to arch tag (attention.utils.get_arch_tag).
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        data_type_choices (dict): a map from PyTorch data types to cuDNN data types. Empty if device
+        is not supported.
+
+    """
+
+    if arch_tag < 80:
+        log.debug("cuDNN Attention is not supported because compute capability is below the minimum (8.0).")
+        return {}
+
+    ## NOTE (ahassani): As of version 91400 FP8 inference via the python frontend does
+    ## not seem to work.
+    # if arch_tag in [90, 100]:
+    #     log.debug(f"cuDNN Attention supports FP8 for {arch_tag=}.")
+    #     return {
+    #         torch.float16: cudnn.data_type.HALF,
+    #         torch.bfloat16: cudnn.data_type.BFLOAT16,
+    #         torch.float8_e4m3fn: cudnn.data_type.FP8_E4M3,
+    #         torch.float8_e5m2: cudnn.data_type.FP8_E5M2,
+    #     }
+
+    log.debug(f"cuDNN Attention only supports FP16 and BF16 for {arch_tag=}.")
+    return {
+        torch.float16: cudnn.data_type.HALF,
+        torch.bfloat16: cudnn.data_type.BFLOAT16,
+    }
+
+
+def cudnn_sdpa_fwd_generate_operands(
+    q: Tensor, k: Tensor, v: Tensor, num_heads: int, return_lse: bool = False
+) -> tuple[Tensor, Tensor, Tensor, Tensor, Tensor | None]:
+    """
+    Takes torch input operands (Q, K, V), validates them, and returns views compatible with cuDNN
+    APIs ("strided" view with heads-first logical layout but heads-last physical layout.
+
+    NOTE: this operation tries to specifically avoid memory copies and express everything as tensor
+    views, therefore it is crucial to not manipulate the outputs in __any way__ after this point,
+    and directly call cuDNN SDPA operations on it.
+    This is also what makes this operation very efficient and low in overhead, as there are no
+    device/CUDA operations or barriers with host/CPU.
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`)
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`)
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`)
+
+        num_heads (int): Number of attention heads. Used for layout validation.
+
+    Other Parameters:
+        return_lse (bool): Whether to store and return the logsumexp values. Default is False.
+
+    Returns:
+        query_cudnn_layout (Tensor): 4-D query tensor, with the cuDNN strided layout
+            (`[batch, heads, seqlen, head_dim]`).
+
+        key_cudnn_layout (Tensor): 4-D key tensor, with the cuDNN strided layout
+            (`[batch, heads_kv, seqlen_kv, head_dim]`).
+
+        value_cudnn_layout (Tensor): 4-D output tensor, with the cuDNN strided layout
+            (`[batch, heads_kv, seqlen_kv, head_dim_v]`).
+
+        output_cudnn_layout (Tensor): 4-D output tensor, with the cuDNN strided layout
+            (`[batch, heads, seqlen, head_dim_v]`).
+
+        logsumexp_cudnn_layout (Tensor | None): only returned when return_lse is True. logsumexp
+            tensor, with the cuDNN strided layout (`[batch, heads, seqlen, 1]`).
+    """
+
+    if q.shape[0] != k.shape[0] or q.shape[0] != v.shape[0]:
+        raise ValueError(
+            f"All attention operands must match in batch size, got {q.shape[0]=}, {k.shape[0]=}, {v.shape[0]=}."
+        )
+
+    if q.shape[-1] != k.shape[-1]:
+        raise ValueError(f"Query and key must match in head dim, got {q.shape[-1]=}, {k.shape[-1]=}.")
+
+    if q.shape[-2] != num_heads:
+        raise ValueError(
+            f"The heads-last layout considers q.shape[-2] as number of heads, got {q.shape[-2]=} but {num_heads=}."
+        )
+
+    if k.shape[-2] != num_heads:
+        raise ValueError(
+            f"The heads-last layout considers k.shape[-2] as number of heads, got {k.shape[-2]=} but {num_heads=}."
+        )
+
+    if v.shape[-2] != num_heads:
+        raise ValueError(
+            f"The heads-last layout considers v.shape[-2] as number of heads, got {v.shape[-2]=} but {num_heads=}."
+        )
+
+    if not q.is_contiguous() or not k.is_contiguous() or not v.is_contiguous():
+        raise ValueError(
+            "All attention operands must be contiguous, got "
+            f"{q.is_contiguous()=}, {k.is_contiguous()=}, {v.is_contiguous()=}."
+        )
+
+    if q.dtype != k.dtype or q.dtype != v.dtype:
+        raise ValueError(f"All attention operands must match in dtype, got {q.dtype=}, {k.dtype=}, {v.dtype=}.")
+
+    if q.device != k.device or q.device != v.device:
+        raise ValueError(
+            f"All attention operands must be on the same device, got {q.device=}, {k.device=}, {v.device=}."
+        )
+
+    dtype = q.dtype
+    device = q.device
+    arch_tag = get_arch_tag(device)
+    dtype_choices = get_dtype_choices(arch_tag)
+
+    if dtype not in dtype_choices:
+        raise ValueError(f"Data type {dtype} is not supported; choices are: {dtype_choices.keys()}.")
+
+    if arch_tag < 80:
+        raise NotImplementedError(f"cuDNN Attention only supports SM80 and later, but {device=} is SM{arch_tag}.")
+
+    batch, seqlen_q, _, head_dim_qk = q.shape
+    _, _, _, head_dim_v = v.shape
+
+    output = torch.empty([batch, seqlen_q, num_heads, head_dim_v], dtype=dtype, device=device)
+    lse = None
+    if return_lse:
+        lse = torch.empty([batch, seqlen_q, num_heads, 1], dtype=dtype, device=device)
+
+    q_cudnn_layout = q.permute(0, 2, 1, 3)
+    k_cudnn_layout = k.permute(0, 2, 1, 3)
+    v_cudnn_layout = v.permute(0, 2, 1, 3)
+    output_cudnn_layout = output.permute(0, 2, 1, 3)
+    lse_cudnn_layout = None
+    assert q_cudnn_layout.data_ptr() == q.data_ptr()
+    assert k_cudnn_layout.data_ptr() == k.data_ptr()
+    assert v_cudnn_layout.data_ptr() == v.data_ptr()
+    assert output_cudnn_layout.data_ptr() == output.data_ptr()
+
+    if return_lse:
+        lse_cudnn_layout = lse.permute(0, 2, 1, 3)
+        assert lse_cudnn_layout.data_ptr() == lse.data_ptr()
+
+    return q_cudnn_layout, k_cudnn_layout, v_cudnn_layout, output_cudnn_layout, lse_cudnn_layout
+
+
+@lru_cache(maxsize=CUDNN_GRAPH_CACHE_SIZE)
+def cudnn_sdpa_fwd_generate_op(
+    dtype: torch.dtype,
+    device: torch.device,
+    q_shape: Size,
+    q_stride: Size,
+    k_shape: Size,
+    k_stride: Size,
+    v_shape: Size,
+    v_stride: Size,
+    output_shape: Size,
+    output_stride: Size,
+    lse_shape: Size | None = None,
+    lse_stride: Size | None = None,
+    is_causal: bool = False,
+    attn_scale: float | None = None,
+    seqlen_Q: int | None = None,
+    seqlen_KV: int | None = None,
+) -> Callable:
+    """
+    Takes use case metadata that has been validated and generated by cudnn_sdpa_fwd_generate_operands
+    and returns a callable cuDNN SDPA forward operation.
+    This function does NOT perform attention and rather prepares and builds the cuDNN graph
+    responsible for doing so.
+
+    The final callable that it returns will take any q, k, v, output and (optionally) lse tensors
+    matching the same attributes (shape, device, dtype, etc) and call cuDNN SDPA forward on them.
+
+    Parameters:
+        dtype (torch.dtype): Tensor data type for Q, K, V, and output.
+
+        device (torch.device): Torch (CUDA) device where tensors are and where Attention will run.
+
+        q_shape (Size): The shape of the 4-D query tensor with the cuDNN strided layout
+            (`[batch, heads, seqlen, head_dim]`).
+
+        q_stride (Size): The stride of the 4-D query tensor with the cuDNN strided layout.
+
+        k_shape (Size): The shape of the 4-D key tensor with the cuDNN strided layout
+            (`[batch, heads_kv, seqlen_kv, head_dim]`).
+
+        k_stride (Size): The stride of the 4-D key tensor with the cuDNN strided layout.
+
+        v_shape (Size): The shape of the 4-D value tensor with the cuDNN strided layout
+            (`[batch, heads_kv, seqlen_kv, head_dim_v]`).
+
+        v_stride (Size): The stride of the 4-D value tensor with the cuDNN strided layout.
+
+        output_shape (Size): The shape of the 4-D output tensor with the cuDNN strided layout
+            (`[batch, heads, seqlen, head_dim_v]`).
+
+        output_stride (Size): The stride of the 4-D output tensor with the cuDNN strided layout.
+
+        lse_shape (Size | None): The shape of the 4-D logsumexp tensor with the cuDNN strided
+            layout (`[batch, heads, seqlen, 1]`).
+
+        lse_stride (Size | None): The stride of the 4-D logsumexp tensor with the cuDNN strided
+            layout.
+
+    Other Parameters:
+        is_causal (bool): whether or not causal masking is enabled. Default is False.
+
+        attn_scale (float | None): Dot product scale (attention scale). Defaults to
+            head_dim ** -0.5.
+
+    Returns:
+        cudnn_sdpa_forward_exec (Callable): Function executing the cuDNN graph with the SDPA
+            forward operation. Function signature:
+
+                query_cudnn_layout (Tensor): 4-D query tensor, with the cuDNN strided layout
+                    (`[batch, heads, seqlen, head_dim]`).
+
+                key_cudnn_layout (Tensor): 4-D key tensor, with the cuDNN strided layout
+                    (`[batch, heads_kv, seqlen_kv, head_dim]`).
+
+                value_cudnn_layout (Tensor): 4-D output tensor, with the cuDNN strided layout
+                    (`[batch, heads_kv, seqlen_kv, head_dim_v]`).
+
+                output_cudnn_layout (Tensor): 4-D output tensor, with the cuDNN strided layout
+                    (`[batch, heads, seqlen, head_dim_v]`).
+
+                logsumexp_cudnn_layout (Tensor | None): Optional logsumexp tensor, with the
+                    cuDNN strided layout (`[batch, heads, seqlen, 1]`).
+    """
+
+    attn_scale = attn_scale if attn_scale is not None else q_shape[-1] ** -0.5
+
+    arch_tag = get_arch_tag(device)
+    dtype_choices = get_dtype_choices(arch_tag)
+
+    assert dtype in dtype_choices
+    cudnn_dtype = dtype_choices[dtype]
+
+    graph = cudnn.pygraph(
+        io_data_type=cudnn_dtype,
+        intermediate_data_type=cudnn.data_type.FLOAT,
+        compute_data_type=cudnn.data_type.FLOAT,
+    )
+
+    q_cudnn = graph.tensor(dim=q_shape, stride=q_stride, data_type=cudnn_dtype)
+    k_cudnn = graph.tensor(dim=k_shape, stride=k_stride, data_type=cudnn_dtype)
+    v_cudnn = graph.tensor(dim=v_shape, stride=v_stride, data_type=cudnn_dtype)
+
+    assert (lse_shape is None and lse_stride is None) or (lse_shape is not None and lse_stride is not None)
+    generate_stats = lse_shape is not None
+
+    seqlen_q_cudnn = None
+    seqlen_kv_cudnn = None
+    use_padding_mask = FORCE_PADDED_MASK or seqlen_Q is not None or seqlen_KV is not None
+    if use_padding_mask:
+        seqlen_Q = seqlen_Q if seqlen_Q is not None else q_shape[2]
+        seqlen_KV = seqlen_KV if seqlen_KV is not None else k_shape[2]
+
+        seqlen_q_cudnn = graph.tensor(dim=[q_shape[0], 1, 1, 1], stride=[1, 1, 1, 1], data_type=cudnn.data_type.INT32)
+        seqlen_kv_cudnn = graph.tensor(dim=[k_shape[0], 1, 1, 1], stride=[1, 1, 1, 1], data_type=cudnn.data_type.INT32)
+
+    o_cudnn, lse_cudnn = graph.sdpa(
+        q=q_cudnn,
+        k=k_cudnn,
+        v=v_cudnn,
+        generate_stats=generate_stats,
+        attn_scale=attn_scale,
+        use_causal_mask=is_causal,
+        use_padding_mask=use_padding_mask,
+        seq_len_q=seqlen_q_cudnn,
+        seq_len_kv=seqlen_kv_cudnn,
+    )
+
+    o_cudnn.set_output(True).set_data_type(cudnn_dtype).set_dim(output_shape).set_stride(output_stride)
+    if generate_stats:
+        lse_cudnn.set_output(True).set_dim(lse_shape).set_stride(lse_stride)
+
+    graph.validate()
+    graph.build_operation_graph()
+    graph.create_execution_plans([cudnn.heur_mode.A, cudnn.heur_mode.FALLBACK])
+    graph.check_support()
+    graph.build_plans()
+
+    workspace_size_bytes = graph.get_workspace_size()
+    log.debug(f"Generated cuDNN Attention graph. Scratch space required: {workspace_size_bytes} bytes.")
+
+    handle = cudnn.create_handle()
+
+    def cudnn_operation(q: Tensor, k: Tensor, v: Tensor, output: Tensor, lse: Tensor | None = None):
+        # NOTE: This is INCREDIBLY important to do -- this is what wasted days of my time
+        # with random NaNs and illegal memory accesses and things of that nature.
+        stream = torch.cuda.current_stream(q.device)
+        cudnn.set_stream(handle=handle, stream=stream.cuda_stream)
+
+        # caching allocator plays nicely with the LRU cache over this, but for now let's avoid
+        # premature optimization.
+        workspace = torch.zeros(workspace_size_bytes, device=device, dtype=torch.uint8)
+
+        variant_pack = {
+            q_cudnn: q,
+            k_cudnn: k,
+            v_cudnn: v,
+            o_cudnn: output,
+        }
+
+        if use_padding_mask:
+            batch = k.shape[0]
+            seqlen_q_cu = torch.tensor([seqlen_Q for _ in range(batch)]).to(device).reshape(batch, 1, 1, 1)
+            seqlen_kv_cu = torch.tensor([seqlen_KV for _ in range(batch)]).to(device).reshape(batch, 1, 1, 1)
+            log.debug(f"{q.shape=}, {k.shape=}, {seqlen_q_cu=}, {seqlen_kv_cu=}")
+            variant_pack[seqlen_q_cudnn] = seqlen_q_cu
+            variant_pack[seqlen_kv_cudnn] = seqlen_kv_cu
+
+        if generate_stats:
+            assert lse is not None
+            assert lse_cudnn is not None
+            variant_pack[lse_cudnn] = lse
+        else:
+            assert lse is None and lse_cudnn is None
+
+        log.debug("Generated cuDNN Attention graph executed")
+        return graph.execute(variant_pack, workspace, handle=handle)
+
+    return cudnn_operation
+
+
+def cudnn_sdpa_fwd_post_process(
+    output_cudnn_layout: Tensor,
+    lse_cudnn_layout: Tensor | None = None,
+) -> tuple[Tensor, Tensor | None]:
+    """
+    Takes torch tensor views validated and generated by cudnn_sdpa_fwd_generate_operands and
+    maps back to torch contiguous layout (heads-last both logical and physical).
+    It should be called after the cuDNN operation.
+
+    Like cudnn_sdpa_fwd_generate_operands, this function is expected to be minimal overhead.
+
+    Parameters:
+        output_cudnn_layout (Tensor): 4-D output tensor, with the cuDNN strided layout
+            (`[batch, heads, seqlen, head_dim_v]`).
+
+        logsumexp_cudnn_layout (Tensor | None): Optional logsumexp tensor, with the cuDNN
+            strided layout (`[batch, heads, seqlen, 1]`).
+
+    Returns:
+        output (Tensor): 4-D output tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim_v]`).
+
+        logsumexp (Tensor | None): Optional logsumexp tensor, with the heads-last contiguous
+            layout (`[batch, seqlen, heads, 1]`).
+    """
+
+    output = output_cudnn_layout.permute(0, 2, 1, 3)
+    lse = None
+    assert output.data_ptr() == output_cudnn_layout.data_ptr()
+
+    if lse_cudnn_layout is not None:
+        lse = lse_cudnn_layout.permute(0, 2, 1, 3)
+        assert lse.data_ptr() == lse_cudnn_layout.data_ptr()
+
+    return output, lse

REGEN-main/cosmos_policy/_src/imaginaire/attention/cudnn/functions.py

@@ -0,0 +1,262 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+cuDNN Backend: intermediate APIs
+Only safe to import when CUDNN_SUPPORTED is True.
+"""
+
+import time
+from functools import partial
+
+import torch
+from torch import Tensor
+from torch.amp import custom_bwd, custom_fwd
+from torch.autograd import Function
+
+from cosmos_policy._src.imaginaire.attention.cudnn.checks import cudnn_attention_check
+from cosmos_policy._src.imaginaire.attention.cudnn.cudnn_forward import (
+    cudnn_sdpa_fwd_generate_op,
+    cudnn_sdpa_fwd_generate_operands,
+    cudnn_sdpa_fwd_post_process,
+)
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+amp_fwd = partial(custom_fwd, device_type="cuda")
+amp_bwd = partial(custom_bwd, device_type="cuda")
+
+
+CUDNN_PADDING_REQUIRED = False
+
+
+class CudnnAttentionAutogradFn(Function):
+    @staticmethod
+    @amp_fwd
+    def forward(
+        ctx,
+        query: Tensor,
+        key: Tensor,
+        value: Tensor,
+        num_heads: int,
+        is_causal: bool,
+        scale: float,
+    ) -> tuple[Tensor, Tensor]:
+        query = query.contiguous()
+        key = key.contiguous()
+        value = value.contiguous()
+
+        seqlen_Q = None
+        seqlen_KV = None
+        padding_Q = 0
+        padding_KV = 0
+
+        # NOTE (ahassani): this may resolve some of the bugs caused by weird seqlens,
+        # but as of 11/12/2025 does not seem to fix any issues. Keeping here in case
+        # it ever comes back.
+        if CUDNN_PADDING_REQUIRED:
+            Q_multiplier = 256
+            KV_multiplier = 256
+
+            if query.shape[1] % Q_multiplier != 0:
+                seqlen_Q = query.shape[1]
+                padding_Q = Q_multiplier - (seqlen_Q % Q_multiplier)
+
+                old_shape = query.shape
+                query = torch.nn.functional.pad(query, (0, 0, 0, 0, 0, padding_Q), "constant", 0)
+                log.debug(f"cuDNN Attention: padded query from {old_shape} to {query.shape}.")
+
+            if key.shape[1] % KV_multiplier != 0:
+                seqlen_KV = key.shape[1]
+                padding_KV = KV_multiplier - (seqlen_KV % KV_multiplier)
+
+                old_shape = key.shape
+                key = torch.nn.functional.pad(key, (0, 0, 0, 0, 0, padding_KV), "constant", 0)
+                value = torch.nn.functional.pad(value, (0, 0, 0, 0, 0, padding_KV), "constant", 0)
+                log.debug(f"cuDNN Attention: padded KV from {old_shape} to {key.shape}.")
+
+        # Transform operands to cuDNN-compatible layouts, make output tensors
+        (q_cudnn_layout, k_cudnn_layout, v_cudnn_layout, output_cudnn_layout, lse_cudnn_layout) = (
+            cudnn_sdpa_fwd_generate_operands(q=query, k=key, v=value, num_heads=num_heads, return_lse=True)
+        )
+
+        # Construct graph
+        assert q_cudnn_layout.device == k_cudnn_layout.device == v_cudnn_layout.device == output_cudnn_layout.device
+        assert q_cudnn_layout.dtype == k_cudnn_layout.dtype == v_cudnn_layout.dtype == output_cudnn_layout.dtype
+        cudnn_graph_gen_start = time.time() * 1e3
+        cudnn_sdpa = cudnn_sdpa_fwd_generate_op(
+            dtype=q_cudnn_layout.dtype,
+            device=q_cudnn_layout.device,
+            q_shape=q_cudnn_layout.shape,
+            q_stride=q_cudnn_layout.stride(),
+            k_shape=k_cudnn_layout.shape,
+            k_stride=k_cudnn_layout.stride(),
+            v_shape=v_cudnn_layout.shape,
+            v_stride=v_cudnn_layout.stride(),
+            output_shape=output_cudnn_layout.shape,
+            output_stride=output_cudnn_layout.stride(),
+            lse_shape=None if lse_cudnn_layout is None else lse_cudnn_layout.shape,
+            lse_stride=None if lse_cudnn_layout is None else lse_cudnn_layout.stride(),
+            is_causal=is_causal,
+            attn_scale=scale,
+            seqlen_Q=seqlen_Q,
+            seqlen_KV=seqlen_KV,
+        )
+        cudnn_graph_gen_time = time.time() * 1e3 - cudnn_graph_gen_start
+        log.debug(f"cuDNN Attention forward graph generation took {cudnn_graph_gen_time:.1f} ms.")
+
+        # Execute graph
+        cudnn_sdpa(
+            q=q_cudnn_layout,
+            k=k_cudnn_layout,
+            v=v_cudnn_layout,
+            output=output_cudnn_layout,
+            lse=lse_cudnn_layout,
+        )
+
+        # Transform outputs back to torch contiguous layouts
+        output, logsumexp = cudnn_sdpa_fwd_post_process(
+            output_cudnn_layout=output_cudnn_layout,
+            lse_cudnn_layout=lse_cudnn_layout,
+        )
+
+        ctx.save_for_backward(q_cudnn_layout, k_cudnn_layout, v_cudnn_layout, lse_cudnn_layout, output_cudnn_layout)
+        ctx.num_heads = num_heads
+        ctx.scale = scale
+
+        if padding_Q > 0:
+            old_shape = output.shape
+            output = output[:, :seqlen_Q, :, :]
+            logsumexp = logsumexp[:, :seqlen_Q, :, :]
+            assert output.shape[1] == seqlen_Q
+            assert logsumexp.shape[1] == seqlen_Q
+            log.debug(f"cuDNN Attention: unpadded output from {old_shape} to {output.shape}.")
+
+        return output, logsumexp
+
+    @staticmethod
+    @amp_bwd
+    def backward(
+        ctx, grad_out: Tensor, grad_lse: Tensor
+    ) -> tuple[
+        Tensor,
+        Tensor,
+        Tensor,
+        None,
+        None,
+        None,
+    ]:
+        raise NotImplementedError()
+
+
+def cudnn_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool = False,
+    causal_type: CausalType | None = None,
+    scale: float | None = None,
+    cumulative_seqlen_Q: Tensor | None = None,
+    cumulative_seqlen_KV: Tensor | None = None,
+    max_seqlen_Q: int | None = None,
+    max_seqlen_KV: int | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    """
+    Runs cuDNN Attention on given operands (Q, K, V) with the heads-last contiguous layout
+        (`[batch, seqlen, heads, head_dim]`).
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`)
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`)
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`)
+
+        is_causal (bool): whether or not causal masking is enabled. Default is False.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`. Required when `is_causal = True`.
+
+        scale (float | None): Dot product scale (attention scale). Defaults to head_dim ** -0.5.
+
+        cumulative_seqlen_Q (Tensor | None): (varlen) Optional 1-D tensor with size `batch + 1`
+            indicating the cumulative sum of number of query tokens in each batch, with an
+            additional 0 element in the beginning. Must be passed together with
+            `cumulative_seqlen_KV` and `max_seqlen_{Q,KV}`.
+
+        cumulative_seqlen_KV (Tensor | None): (varlen) Optional 1-D tensor with size `batch + 1`
+            indicating the cumulative sum of number of key/value tokens in each batch, with an
+            additional 0 element in the beginning. Must be passed together with
+            `cumulative_seqlen_Q` and `max_seqlen_{Q,KV}`.
+
+        max_seqlen_Q (int | None): (varlen) Optional integer indicating the maximum query
+            sequence length in all batches. Must be passed together with `cumulative_seqlen_{Q,KV}`
+            and `max_seqlen_KV`.
+
+        max_seqlen_KV (int | None): (varlen) Optional integer indicating the maximum key/value
+            sequence length in all batches. Must be passed together with `cumulative_seqlen_{Q,KV}`
+            and `max_seqlen_Q`.
+
+    Other Parameters:
+        return_lse (bool): Whether to return the logsumexp values. Default is False.
+
+        backend_kwargs (dict | None): Key-value pair for passing arguments specific to cuDNN's
+            attention operator, if any.
+
+    Returns:
+        output (Tensor): 4-D output tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim_v]`).
+
+        logsumexp (Tensor): logsumexp tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, 1]`). Only returned when return_lse is True.
+    """
+
+    is_varlen = cumulative_seqlen_Q is not None
+    assert cudnn_attention_check(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+        is_varlen=is_varlen,
+        raise_error=True,
+    )
+
+    assert not is_varlen  # cudnn_attention_check should prevent this assertion failing
+
+    num_heads = query.shape[-2]
+    scale = scale if scale is not None else query.shape[-1] ** -0.5
+
+    output, lse = CudnnAttentionAutogradFn.apply(
+        query,
+        key,
+        value,
+        num_heads,
+        is_causal,
+        scale,
+    )
+
+    if return_lse:
+        return output, lse
+
+    return output

REGEN-main/cosmos_policy/_src/imaginaire/attention/cudnn/meta.py

@@ -0,0 +1,63 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+cuDNN Backend: metadata
+Always safe to import (as long as torch is available.)
+"""
+
+import torch
+
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+
+def get_fwd_dtypes(arch_tag: int) -> list[torch.dtype]:
+    """
+    Returns data type choices for forward pass according to arch tag (attention.utils.get_arch_tag).
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        data_type_choices (list): a list of PyTorch data types. Empty if device is not supported.
+
+    """
+
+    if arch_tag < 80:
+        log.debug("cuDNN Attention is not supported because compute capability is below the minimum (8.0).")
+        return []
+
+    ## NOTE (ahassani): As of version 91400 FP8 inference via the python frontend does
+    ## not seem to work.
+    log.debug(f"cuDNN Attention only supports FP16 and BF16 for {arch_tag=}.")
+    return [torch.float16, torch.bfloat16]
+
+
+def get_bwd_dtypes(arch_tag: int) -> list[torch.dtype]:
+    """
+    Returns data type choices for backward pass according to arch tag (attention.utils.get_arch_tag).
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        data_type_choices (list): a list of PyTorch data types. Empty if device is not supported.
+
+    """
+
+    return []

REGEN-main/cosmos_policy/_src/imaginaire/attention/cudnn/stubs.py

@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+cuDNN Backend: intermediate API stubs
+Always safe to import (as long as torch is available.)
+"""
+
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+
+
+def cudnn_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool = False,
+    causal_type: CausalType | None = None,
+    scale: float | None = None,
+    cumulative_seqlen_Q: Tensor | None = None,
+    cumulative_seqlen_KV: Tensor | None = None,
+    max_seqlen_Q: int | None = None,
+    max_seqlen_KV: int | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    raise RuntimeError(
+        "Tried to run cuDNN attention, but it is not supported / available. "
+        "Try running with debug logs enabled to see why."
+    )

REGEN-main/cosmos_policy/_src/imaginaire/attention/docs/README.md

@@ -0,0 +1,10 @@
+# Imaginaire Attention Subpackage Docs
+
+* [Basic API & Intro](../README.md)
+* Docs (you are here)
+    * [Backends](backends.md)
+    * Features
+        * [Basic features](features.md)
+        * [Multi-dimensional Attention](multi-dim.md)
+            * [Spatio-Temporal Attention](multi-dim.md#spatio-temporal-attention)
+    * [APIs](apis.md)

REGEN-main/cosmos_policy/_src/imaginaire/attention/docs/apis.md

@@ -0,0 +1,28 @@
+# Imaginaire Attention Subpackage Docs > APIs
+
+## Attention
+
+::: cosmos_policy._src.imaginaire.attention
+    options:
+          heading_level: 3
+          show_object_full_path: true
+          members:
+              - attention
+
+## Multi-Dimensional Attention
+
+::: cosmos_policy._src.imaginaire.attention
+    options:
+          heading_level: 3
+          show_object_full_path: true
+          members:
+              - multi_dimensional_attention
+
+### Spatio-Temporal Attention
+
+::: cosmos_policy._src.imaginaire.attention
+    options:
+          heading_level: 3
+          show_object_full_path: true
+          members:
+              - spatio_temporal_attention

REGEN-main/cosmos_policy/_src/imaginaire/attention/docs/backends.md

@@ -0,0 +1,73 @@
+# Imaginaire Attention Subpackage Docs > Backends
+
+The goal is to support as many stable and reliable backends as possible, both for feature coverage,
+and for delivering the best performance.
+
+## NATTEN
+[NATTEN](https://natten.org) ships standard Attention kernels in addition to sparse /
+multi-dimensional kernels.
+
+Minimum version required: `0.21.5.dev3`.
+
+### Feature coverage
+
+| Feat/Backend | Ampere/RTX         | Hopper | Blackwell          |
+|--------------|--------------------|--------|--------------------|
+| Causal mask  | :white_check_mark: |        | :white_check_mark: |
+| Varlen       | :white_check_mark: |        | :white_check_mark: |
+| GQA/MQA      |                    |        | :white_check_mark: |
+| MLA          | :white_check_mark: |        |                    |
+
+This backend supports torch compile.
+
+## Flash Attention v2
+
+Flash Attention v2 (original C++ kernels) are available under the `flash2` backend.
+Requires the `flash_attn` package.
+
+Minimum version required: `2.7.0`.
+Maximum version supported: `2.7.4`.
+
+This backend supports torch compile.
+
+### Feature coverage
+
+| Feat/Backend | Ampere/RTX         |
+|--------------|--------------------|
+| Causal mask  | :white_check_mark: |
+| Varlen       | :white_check_mark: |
+| GQA/MQA      | :white_check_mark: |
+| MLA          |                    |
+
+## Flash Attention v3
+
+Flash Attention v3 (original C++ kernels) are available under the `flash3` backend.
+Requires the `flash_attn_3` package.
+
+Version required: `3.0.0.b*`.
+
+### Feature coverage
+
+| Feat/Backend | Ampere/RTX         |
+|--------------|--------------------|
+| Causal mask  | :white_check_mark: |
+| Varlen       | :white_check_mark: |
+| GQA/MQA      | :white_check_mark: |
+| MLA          |                    |
+
+MLA is technically supported, but disabled due to an API bug in the backward pass.
+
+Torch compile is NOT yet supported for this backend.
+
+## cuDNN
+
+**NOTE**: due to numerical instability on Blackwell, this backend is not yet fully integrated, and
+is banned for all use cases.
+
+Minimum version required: python frontend: `1.14.0`, backend: `91300`.
+
+Torch compile is NOT yet supported for this backend.
+
+## Future backends
+
+We plan to add Flash Attention 4 (CuTeDSL kernels) and any other relevant backends.

REGEN-main/cosmos_policy/_src/imaginaire/attention/docs/features.md

@@ -0,0 +1,151 @@
+# Imaginaire Attention Subpackage Docs > Features
+
+## Causal mask
+
+Causal masking requires explicit indication of causal mask type.
+For example, simply passing `is_causal=True` will fail:
+
+```python
+output = attention(
+    query=query,
+    key=key,
+    value=value,
+    is_causal=True
+)
+```
+
+Result:
+```
+ValueError: Argument causal_type must be specified when is_causal=True.
+```
+
+There are currently two types of causal masking that are supported, and many popular backends tend
+to support only one. It's therefore critical to to choose the correct one for your application.
+
+
+```python
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+
+# Causal type choices:
+#   - CausalType.TopLeft
+#   - CausalType.BottomRight
+
+output = attention(
+    query=query,
+    key=key,
+    value=value,
+    is_causal=True,
+    causal_type=CausalType.TopLeft,
+)
+```
+
+### Top-left causal mask
+
+Q sequence length = KV sequence length = 5
+
+|    | K1        | K2        | K3        | K4        | K5        |
+|----|-----------|-----------|-----------|-----------|-----------|
+| Q1 | ✓  | ✗  | ✗  | ✗  | ✗  |
+| Q2 | ✓  | ✓  | ✗  | ✗  | ✗  |
+| Q3 | ✓  | ✓  | ✓  | ✗  | ✗  |
+| Q4 | ✓  | ✓  | ✓  | ✓  | ✗  |
+| Q5 | ✓  | ✓  | ✓  | ✓  | ✓  |
+
+Q sequence length = 2, KV sequence length = 5
+
+|    | K1        | K2        | K3        | K4        | K5        |
+|----|-----------|-----------|-----------|-----------|-----------|
+| Q1 | ✓  | ✗  | ✗  | ✗  | ✗  |
+| Q2 | ✓  | ✓  | ✗  | ✗  | ✗  |
+
+Q sequence length = 5, KV sequence length = 2
+
+|    | K1        | K2        |
+|----|-----------|-----------|
+| Q1 | ✓  | ✗  |
+| Q2 | ✓  | ✓  |
+| Q3 | ✓  | ✓  |
+| Q4 | ✓  | ✓  |
+| Q5 | ✓  | ✓  |
+
+### Bottom-right causal mask
+
+Q sequence length = KV sequence length = 5
+
+|    | K1        | K2        | K3        | K4        | K5        |
+|----|-----------|-----------|-----------|-----------|-----------|
+| Q1 | ✓  | ✗  | ✗  | ✗  | ✗  |
+| Q2 | ✓  | ✓  | ✗  | ✗  | ✗  |
+| Q3 | ✓  | ✓  | ✓  | ✗  | ✗  |
+| Q4 | ✓  | ✓  | ✓  | ✓  | ✗  |
+| Q5 | ✓  | ✓  | ✓  | ✓  | ✓  |
+
+(identical to top-left in this special case)
+
+Q sequence length = 2, KV sequence length = 5
+
+|    | K1        | K2        | K3        | K4        | K5        |
+|----|-----------|-----------|-----------|-----------|-----------|
+| Q1 | ✓  | ✓  | ✓  | ✓  | ✗  |
+| Q2 | ✓  | ✓  | ✓  | ✓  | ✓  |
+
+Q sequence length = 5, KV sequence length = 2
+
+|    | K1        | K2        |
+|----|-----------|-----------|
+| Q1 | ✗  | ✗  |
+| Q2 | ✗  | ✗  |
+| Q3 | ✗  | ✗  |
+| Q4 | ✓  | ✗  |
+| Q5 | ✓  | ✓  |
+
+## GQA/MQA
+
+Simply pass `key` and `value` without repeating attention heads.
+
+**NOTE**: `key`/`value` heads must evenly divide `query` heads.
+
+**NOTE**: the behavior is similar to `repeat_interleave`, not `repeat`.
+
+## Variable length
+
+**(Less efficient option)** Pass sequence lengths directly:
+
+```python
+output = attention(
+    query=query,
+    key=key,
+    value=value,
+    seqlens_Q=torch.tensor(sequence_length_list_Q, device=query.device),
+    seqlens_KV=torch.tensor(sequence_length_list_KV, device=query.device),
+)
+```
+
+This will manually compute the maximum sequence lengths, and cumulative sums (with the additional
+padding).
+
+**(More efficient option)** Compute cumulative sequence lengths and maximums once, and reuse it:
+
+```python
+from cosmos_policy._src.imaginaire.attention.varlen import generate_varlen_parameters
+
+# NOTE: query, key, and value are only used for verification, so it doesn't matter what model layer
+# they correspond to.
+(
+    cumulative_seqlen_Q,
+    cumulative_seqlen_KV,
+    max_seqlen_Q,
+    max_seqlen_KV,
+) = generate_varlen_parameters(query, key, value, seqlens_Q, seqlens_KV)
+
+# in all attention layers that follow:
+output = attention(
+    query=query,
+    key=key,
+    value=value,
+    cumulative_seqlen_Q=cumulative_seqlen_Q,
+    cumulative_seqlen_KV=cumulative_seqlen_KV,
+    max_seqlen_Q=max_seqlen_Q,
+    max_seqlen_KV=max_seqlen_KV,
+)
+```

REGEN-main/cosmos_policy/_src/imaginaire/attention/docs/multi-dim.md

@@ -0,0 +1,111 @@
+# Imaginaire Attention Subpackage Docs > Features > Multi-Dimensional Attention
+
+Multi-Dimensional Attention is the primary API for handling various complex masks and sparsity
+patterns, such as the spatio-temporal mask, and sliding window attention.
+
+## Basic API
+
+```python
+from cosmos_policy._src.imaginaire.attention import multi_dimensional_attention
+
+output = multi_dimensional_attention(
+    query=query,
+    key=key,
+    value=value,
+)
+```
+
+Sparsity parameters:
+* **Optional** `window_size`: allows reducing the attention span by limiting each token's context to
+    a local sliding window. References:
+    * [Image Transformer](https://arxiv.org/abs/1802.05751)
+    * [Stand-alone self-attention](https://arxiv.org/abs/1906.05909)
+    * [Neighborhood attention transformer](https://arxiv.org/abs/2204.07143)
+* **Optional** `dilation`: introduces gaps between the tokens within a sliding window, capturing
+    global context without more computation.
+    Reference: [Dilated neighborhood attention transformer](https://arxiv.org/abs/2209.15001)
+
+Other masking parameters:
+* **Optional** `stride`: introduces delays into the sliding window, for __potential__ efficiency
+    gains. Reference: [Generalized Neighborhood Attention](https://arxiv.org/abs/2504.16922).
+* **Optional** `is_causal`: allows causally masking individual dimensions. This parameter can
+    implement the spatio-temporal mask (causal masking across temporal dimension, bi-directional
+    along space).
+
+All sparsity / masking parameters can be specified **per dimension**.
+The key feature of `multi_dimensional_attention` over the standard `attention` API is supporting
+multi-dimensional layouts of tokens (i.e. multi-dimensional feature maps).
+
+This means `query`, `key` and `value` are not necessarily 4-D tensors; they can be 4-D, 5-D, or 6-D,
+representing 1-D, 2-D, and 3-D token layouts (see [Tensor layouts](#tensor-layouts)).
+
+* **Optional** `scale`: attention (softmax/dot product) scale. Defaults to `head_dim ** -0.5`.
+* **Optional** `return_lse`: returns logsumexp if `True`
+* **Optional** `backend`: explicitly set backend instead of automatically selecting the best compatible
+
+## Tensor layouts
+
+In addition to requiring the [contiguous heads-last tensor layout](../README.md#tensor-layouts),
+Multi-Dimensional Attention also requires the "sequence length" dimension to be unrolled / unfolded
+back into its original representation:
+
+```python
+# 1-D case: language, audio
+batch, X, heads, head_dim = query_1d.shape
+#      _
+#      ^
+#      |
+#      |-----> token layout shape
+
+# 2-D case: images
+batch, X, Y, heads, head_dim = query_2d.shape
+#      ____
+#        ^
+#        |
+#        |-----> token layout shape
+
+# 3-D case: videos / 3-D images
+batch, X, Y, Z, heads, head_dim = query_3d.shape
+#      _______
+#         ^
+#         |
+#         |------> token layout shape
+```
+
+Multi-Dimensional Attention also requires the shapes of `query`, `key` and `value` to match along
+those dimensions, henceforth called the **token layout shape**:
+
+```python
+assert query_1d.shape[1:2] == key_1d.shape[1:2] == value_1d.shape[1:2]
+
+assert query_2d.shape[1:3] == key_2d.shape[1:3] == value_2d.shape[1:3]
+
+assert query_3d.shape[1:4] == key_3d.shape[1:4] == value_3d.shape[1:4]
+```
+
+This is because of the large number of sparsity / masking features (and their combinations)
+supported, which is mainly possible by making the assumption that query and context coordinate
+spaces are the same, eliminating the requirement for a mapping between the two.
+
+Problems with a different query and key/value token layout shape may be supported in the future.
+
+
+## Backends
+The only backend supporting multi-dimensional attention for now is `natten`.
+
+## Spatio-Temporal Attention
+
+Spatio-Temporal attention (causal masking across the time dimension, and no masking / bi-directional
+across spatial dimensions) is a special case of Multi-Dimensional Attention.
+You can either implement it by marking `is_causal` as expected in `multi_dimensional_attention`, or
+directly use `spatio_temporal_attention`:
+
+```python
+from cosmos_policy._src.imaginaire.attention import spatio_temporal_attention
+
+output = spatio_temporal_attention(
+    query=query,
+    key=key,
+    value=value,
+)
+```

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash2/README.md

@@ -0,0 +1,71 @@
+## Causal Mask
+
+NOTE: Flash only implements bottom-right-aligned causal mask, but the default
+in SDPA, CUTLASS/NATTEN, cuDNN is top-left.
+To get the same behavior, we __might__ be able to implement top-left-aligned with
+the sliding window argument, but some of Flash's overrides prevent this...
+
+```python
+seqlen_q = query.shape[1]
+seqlen_k = key.shape[1]
+
+# From Flash Attn readme:
+#     Query at position i will only attend to keys between
+#     [i + seqlen_k - seqlen_q - window_size[0], i + seqlen_k - seqlen_q + window_size[1]] inclusive.
+#
+# so our window_size when doing top-left causal masking should satisfy:
+#  i + seqlen_k - seqlen_q - window_size[0] = 0
+#  i + seqlen_k - seqlen_q + window_size[1] = i
+# =>
+#  seqlen_k - seqlen_q + window_size[1] = 0 ==>
+#  window_size[1] = seqlen_q - seqlen_k
+#
+# and:
+#
+#  i + seqlen_k - seqlen_q = window_size[0]
+#
+# which has to be satisfied for all 0 <= i < seqlen_q:
+#  seqlen_k - seqlen_q = window_size[0]
+#
+#  seqlen_q - 1 + seqlen_k - seqlen_q = window_size[0] ==>
+#   seqlen_k - 1 = window_size[0]
+#
+# which means ...
+#
+#
+# Other Flash overrides:
+#      if (window_size_left >= seqlen_k) { window_size_left = -1; }
+#      if (window_size_right >= seqlen_k) { window_size_right = -1; }
+#
+#      params.is_causal = window_size_left < 0 && window_size_right == 0;
+#
+#      if (window_size_left < 0 && window_size_right >= 0) { window_size_left = seqlen_k; }
+#      if (window_size_left >= 0 && window_size_right < 0) { window_size_right = seqlen_k; }
+#      params.window_size_left = window_size_left;
+#      params.window_size_right = window_size_right;
+#
+# scheduler:
+#      n_block_min = max(0, (m_block * kBlockM + seqlen_k - seqlen_q - window_size_left) / kBlockN);
+#      n_block_max = min(n_block_max, ceil_div((m_block + 1) * kBlockM + seqlen_k - seqlen_q + window_size_right, kBlockN));
+#
+
+flash_causal = False
+window_size = (-1, -1) if not is_causal else (seqlen_k, seqlen_q - seqlen_k)
+if is_causal and seqlen_k < seqlen_q:
+    window_size = (-1, 0)
+
+    padding_KV = seqlen_q - seqlen_k
+    old_shape = key.shape
+    key = torch.nn.functional.pad(key, (0, 0, 0, 0, 0, padding_KV), "constant", 0)
+    value = torch.nn.functional.pad(value, (0, 0, 0, 0, 0, padding_KV), "constant", 0)
+    log.debug(f"Flash Attention: padded KV from {old_shape} to {key.shape}.")
+
+print(f"{window_size=}")
+
+#window_size = (-1, -1) if not is_causal else (-1, 0)
+#window_size = (-1, -1) if not is_causal else (-1, seqlen_q - seqlen_k)
+
+# seqlen_q=7688, seqlen_kv=2048, is_causal=True
+#      n_block_min = max(0, (q_start - 7688) / kBlockN);
+#      n_block_max = min(n_block_max, ceil_div(q_end, kBlockN));
+```

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash2/__init__.py

@@ -0,0 +1,96 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Flash Attention v2 (flash2) Backend
+"""
+
+import torch
+
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+# We lock to safe releases of Flash 2
+# We will have a separate backend identifier for 2025 releases with CuTeDSL
+# kernels.
+FLASH_ATTENTION_V2_MIN_VERSION = [2, 7, 0]
+FLASH_ATTENTION_V2_MAX_VERSION = [2, 7, 4]
+
+
+def flash2_supported() -> bool:
+    """
+    Returns whether Flash Attention is supported in this environment.
+    Requirements are:
+        * Presence of CUDA Runtime (via PyTorch)
+        * Presence of Flash Attention, meeting minimum version requirements
+
+    This check guards imports / dependencies on the Flash Attention package.
+    """
+    if not torch.cuda.is_available():
+        log.debug("Flash Attention v2 is not supported because PyTorch did not detect CUDA runtime.")
+        return False
+
+    try:
+        import flash_attn
+
+    except ImportError:
+        log.debug("Flash Attention v2 is not supported because the Python package was not found.")
+        return False
+    except Exception as e:
+        log.debug(f"Flash Attention v2 is not supported because importing the Python package failed: {e}")
+        return False
+
+    flash2_version_str = None
+    if not hasattr(flash_attn, "__version__"):
+        from importlib.metadata import version
+
+        flash2_version_str = version("flash_attn")
+    else:
+        flash2_version_str = flash_attn.__version__
+
+    flash2_version_split = flash2_version_str.split(".")
+    if len(flash2_version_split) < 3:
+        log.debug(f"Unable to parse Flash Attention v2 version {flash2_version_str}.")
+        return False
+
+    try:
+        flash2_version = [int(x) for x in flash2_version_split[:3]]
+
+    except ValueError:
+        log.debug(f"Unable to parse Flash Attention v2 version as an int list: {flash2_version_str}.")
+        return False
+
+    if flash2_version > FLASH_ATTENTION_V2_MAX_VERSION or flash2_version < FLASH_ATTENTION_V2_MIN_VERSION:
+        log.debug(
+            "Flash Attention v2 build is not supported; this backend only supports versions "
+            f"{FLASH_ATTENTION_V2_MIN_VERSION} through {FLASH_ATTENTION_V2_MAX_VERSION}, got "
+            f"{flash2_version}."
+        )
+        return False
+
+    return True
+
+
+FLASH2_SUPPORTED = flash2_supported()
+
+if FLASH2_SUPPORTED:
+    from cosmos_policy._src.imaginaire.attention.flash2.functions import flash2_attention
+
+else:
+    from cosmos_policy._src.imaginaire.attention.flash2.stubs import flash2_attention
+
+__all__ = ["flash2_attention", "FLASH2_SUPPORTED"]

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash2/checks.py

@@ -0,0 +1,112 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Flash Attention v2 (flash2) backend checks
+"""
+
+from functools import partial
+
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.checks import attention_param_checks, attention_tensor_checks
+from cosmos_policy._src.imaginaire.attention.flash2 import FLASH2_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.flash2.meta import get_bwd_dtypes, get_fwd_dtypes
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.utils import get_arch_tag, log_or_raise_error
+
+
+def flash2_attention_check(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool,
+    causal_type: CausalType,
+    is_varlen: bool,
+    raise_error: bool = False,
+) -> bool:
+    """
+    Input validation function for the flash2 backend.
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`).
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`).
+
+        is_causal (bool): whether or not causal masking is enabled.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`. Required when `is_causal = True`.
+
+        is_varlen (bool): whether or not a variable length (varlen) use case. Must be inferred
+            beforehand based on arguments such as seqlens_{Q,KV} or cumulative_seqlen_{Q,KV} being
+            passed.
+
+        raise_error (bool): whether to raise an error if any checks fail or no backend is selected,
+            instead of just returning False. Default is False.
+
+    Returns:
+        success (bool): whether use case is compatible with flash2 backend.
+
+    """
+    target_fn = partial(log_or_raise_error, raise_error=raise_error)
+
+    if not FLASH2_SUPPORTED:
+        target_fn(
+            "Flash Attention v2 (flash2) is not supported in this environment. Run with debug logs to find out why, or choose another backend.",
+            exception=RuntimeError,
+        )
+        return False
+
+    arch_tag = get_arch_tag(query.device)
+    fwd_dtypes = get_fwd_dtypes(arch_tag)
+    bwd_dtypes = get_bwd_dtypes(arch_tag)
+    if not attention_tensor_checks(
+        query=query,
+        key=key,
+        value=value,
+        supported_dtypes_forward=fwd_dtypes,
+        supported_dtypes_backward=bwd_dtypes,
+        supports_mla=False,
+        supports_gqa_mqa=True,
+        raise_error=raise_error,
+        backend_name="Flash Attention v2 (flash2)",
+    ):
+        target_fn("Flash Attention v2 (flash2) does not support the given inputs.", exception=RuntimeError)
+        return False
+
+    # Verifies causal_type is a CausalType instance when is_causal
+    # Verifies DontCare is not used unless seqlen_q == seqlen_kv
+    attention_param_checks(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+    )
+
+    if is_causal and causal_type not in [CausalType.BottomRight, CausalType.DontCare]:
+        target_fn("Flash Attention only supports bottom-right causal masking.", exception=RuntimeError)
+        return False
+
+    return True

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash2/functions.py

@@ -0,0 +1,170 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Flash Attention v2 (flash2) Backend: intermediate APIs
+Only safe to import when FLASH2_SUPPORTED is True.
+"""
+
+from flash_attn.flash_attn_interface import flash_attn_func, flash_attn_varlen_func
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.flash2.checks import flash2_attention_check
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+
+
+def flash2_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool = False,
+    causal_type: CausalType | None = None,
+    scale: float | None = None,
+    cumulative_seqlen_Q: Tensor | None = None,
+    cumulative_seqlen_KV: Tensor | None = None,
+    max_seqlen_Q: int | None = None,
+    max_seqlen_KV: int | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    """
+    Runs Flash Attention v2 on given operands (Q, K, V) with the heads-last contiguous layout
+        (`[batch, seqlen, heads, head_dim]`).
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`)
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`)
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`)
+
+        is_causal (bool): whether or not causal masking is enabled. Default is False.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`. Required when `is_causal = True`.
+
+        scale (float | None): Dot product scale (attention scale). Defaults to head_dim ** -0.5.
+
+        cumulative_seqlen_Q (Tensor | None): (varlen) Optional 1-D tensor with size `batch + 1`
+            indicating the cumulative sum of number of query tokens in each batch, with an
+            additional 0 element in the beginning. Must be passed together with
+            `cumulative_seqlen_KV` and `max_seqlen_{Q,KV}`.
+
+        cumulative_seqlen_KV (Tensor | None): (varlen) Optional 1-D tensor with size `batch + 1`
+            indicating the cumulative sum of number of key/value tokens in each batch, with an
+            additional 0 element in the beginning. Must be passed together with
+            `cumulative_seqlen_Q` and `max_seqlen_{Q,KV}`.
+
+        max_seqlen_Q (int | None): (varlen) Optional integer indicating the maximum query
+            sequence length in all batches. Must be passed together with `cumulative_seqlen_{Q,KV}`
+            and `max_seqlen_KV`.
+
+        max_seqlen_KV (int | None): (varlen) Optional integer indicating the maximum key/value
+            sequence length in all batches. Must be passed together with `cumulative_seqlen_{Q,KV}`
+            and `max_seqlen_Q`.
+
+    Other Parameters:
+        return_lse (bool): Whether to return the logsumexp values. Default is False.
+
+        backend_kwargs (dict | None): Key-value pair for passing arguments specific to Flash's
+            attention operator, if any.
+
+    Returns:
+        output (Tensor): 4-D output tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim_v]`).
+
+        logsumexp (Tensor): logsumexp tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, 1]`). Only returned when return_lse is True.
+    """
+
+    is_varlen = cumulative_seqlen_Q is not None
+    assert flash2_attention_check(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+        is_varlen=is_varlen,
+        raise_error=True,
+    )
+
+    scale = scale if scale is not None else query.shape[-1] ** -0.5
+
+    backend_kwargs = backend_kwargs if backend_kwargs is not None else {}
+
+    if is_varlen:
+        assert query.shape[0] == key.shape[0] == value.shape[0] == 1
+        q = query.squeeze(0)
+        k = key.squeeze(0)
+        v = value.squeeze(0)
+        assert q.dim() == k.dim() == v.dim() == 3
+        out, lse_, _ = flash_attn_varlen_func(
+            q=query.squeeze(0),
+            k=key.squeeze(0),
+            v=value.squeeze(0),
+            cu_seqlens_q=cumulative_seqlen_Q,
+            cu_seqlens_k=cumulative_seqlen_KV,
+            max_seqlen_q=max_seqlen_Q,
+            max_seqlen_k=max_seqlen_KV,
+            softmax_scale=scale,
+            causal=is_causal,
+            return_attn_probs=True,
+            **backend_kwargs,
+            # window_size=(-1, -1),
+            # dropout_p=0.0,
+            # softcap=0.0, # 0.0 means deactivated
+            # alibi_slopes=None,
+            # deterministic=False,
+            # block_table=None,
+        )
+        assert out.dim() == 3
+        assert lse_.dim() == 2
+
+        output = out.unsqueeze(0)
+        lse = lse_.unsqueeze(0)
+
+    else:
+        output, lse, _ = flash_attn_func(
+            q=query,
+            k=key,
+            v=value,
+            softmax_scale=scale,
+            causal=is_causal,
+            return_attn_probs=True,
+            **backend_kwargs,
+            # window_size=(-1, -1),
+            # dropout_p=0.0,
+            # softcap=0.0, # 0.0 means deactivated
+            # alibi_slopes=None,
+            # deterministic=False,
+        )
+
+    assert isinstance(output, Tensor)
+    assert isinstance(lse, Tensor)
+    assert output.dim() == 4
+    assert lse.dim() == 3
+
+    lse = lse.permute(0, 2, 1).contiguous()  # [batch, seqlen, head_dim]
+
+    if return_lse:
+        return output, lse
+
+    return output

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash2/meta.py

@@ -0,0 +1,64 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Flash Attention v2 (flash2) Backend: metadata
+Always safe to import (as long as torch is available.)
+"""
+
+import torch
+
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+
+def get_fwd_dtypes(arch_tag: int) -> list[torch.dtype]:
+    """
+    Returns data type choices for forward pass according to arch tag (attention.utils.get_arch_tag).
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        data_type_choices (list): a list of PyTorch data types. Empty if device is not supported.
+
+    """
+
+    if arch_tag < 80:
+        log.debug("Flash Attention v2 (flash2) is not supported because compute capability is below the minimum (8.0).")
+        return []
+
+    return [torch.float16, torch.bfloat16]
+
+
+def get_bwd_dtypes(arch_tag: int) -> list[torch.dtype]:
+    """
+    Returns data type choices for backward pass according to arch tag (attention.utils.get_arch_tag).
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        data_type_choices (list): a list of PyTorch data types. Empty if device is not supported.
+
+    """
+
+    if arch_tag < 80:
+        log.debug("Flash Attention v2 (flash2) is not supported because compute capability is below the minimum (8.0).")
+        return []
+
+    return [torch.float16, torch.bfloat16]

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash2/stubs.py

@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Flash Attention v2 (flash2) Backend: intermediate API stubs
+Always safe to import (as long as torch is available.)
+"""
+
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+
+
+def flash2_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool = False,
+    causal_type: CausalType | None = None,
+    scale: float | None = None,
+    cumulative_seqlen_Q: Tensor | None = None,
+    cumulative_seqlen_KV: Tensor | None = None,
+    max_seqlen_Q: int | None = None,
+    max_seqlen_KV: int | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    raise RuntimeError(
+        "Tried to run Flash Attention v2, but it is not supported / available. "
+        "Try running with debug logs enabled to see why."
+    )

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash3/__init__.py

@@ -0,0 +1,94 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Flash Attention v3 (flash3) Backend
+"""
+
+import torch
+
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+FLASH_ATTENTION_V3_MIN_VERSION = [3, 0, 0, 0]
+FLASH_ATTENTION_V3_MAX_VERSION = [3, 0, 0, 1]
+
+
+def flash3_supported() -> bool:
+    """
+    Returns whether Flash Attention is supported in this environment.
+    Requirements are:
+        * Presence of CUDA Runtime (via PyTorch)
+        * Presence of Flash Attention, meeting minimum version requirements
+
+    This check guards imports / dependencies on the Flash Attention package.
+    """
+    if not torch.cuda.is_available():
+        log.debug("Flash Attention v3 is not supported because PyTorch did not detect CUDA runtime.")
+        return False
+
+    try:
+        import flash_attn_3
+
+    except ImportError:
+        log.debug("Flash Attention v3 is not supported because the Python package was not found.")
+        return False
+    except Exception as e:
+        log.debug(f"Flash Attention v3 is not supported because importing the Python package failed: {e}")
+        return False
+
+    flash3_version_str = None
+    if not hasattr(flash_attn_3, "__version__"):
+        from importlib.metadata import version
+
+        flash3_version_str = version("flash_attn_3")
+    else:
+        flash3_version_str = flash_attn_3.__version__
+
+    flash3_version_split = flash3_version_str.replace("b", ".").split(".")
+    if len(flash3_version_split) != 4:
+        log.debug(f"Unable to parse Flash Attention v3 version {flash3_version_str}.")
+        return False
+
+    try:
+        flash3_version = [int(x) for x in flash3_version_split]
+
+    except ValueError:
+        log.debug(f"Unable to parse Flash Attention v3 version as an int list: {flash3_version_str}.")
+        return False
+
+    if flash3_version > FLASH_ATTENTION_V3_MAX_VERSION or flash3_version < FLASH_ATTENTION_V3_MIN_VERSION:
+        log.debug(
+            "Flash Attention v3 build is not supported; this backend only supports versions "
+            f"{FLASH_ATTENTION_V3_MIN_VERSION} through {FLASH_ATTENTION_V3_MAX_VERSION}, got "
+            f"{flash3_version}."
+        )
+        return False
+
+    return True
+
+
+FLASH3_SUPPORTED = flash3_supported()
+
+
+if FLASH3_SUPPORTED:
+    from cosmos_policy._src.imaginaire.attention.flash3.functions import flash3_attention
+
+else:
+    from cosmos_policy._src.imaginaire.attention.flash3.stubs import flash3_attention
+
+__all__ = ["flash3_attention", "FLASH3_SUPPORTED"]

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash3/checks.py

@@ -0,0 +1,134 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Flash Attention v3 (flash3) backend checks
+"""
+
+from functools import partial
+
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.checks import attention_param_checks, attention_tensor_checks
+from cosmos_policy._src.imaginaire.attention.flash3 import FLASH3_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.flash3.meta import get_bwd_dtypes, get_fwd_dtypes
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.utils import get_arch_tag, is_torch_compiling, log_or_raise_error
+
+
+def flash3_attention_check(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool,
+    causal_type: CausalType,
+    is_varlen: bool,
+    raise_error: bool = False,
+) -> bool:
+    """
+    Input validation function for the flash3 backend.
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`).
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`).
+
+        is_causal (bool): whether or not causal masking is enabled.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`. Required when `is_causal = True`.
+
+        is_varlen (bool): whether or not a variable length (varlen) use case. Must be inferred
+            beforehand based on arguments such as seqlens_{Q,KV} or cumulative_seqlen_{Q,KV} being
+            passed.
+
+        raise_error (bool): whether to raise an error if any checks fail or no backend is selected,
+            instead of just returning False. Default is False.
+
+    Returns:
+        success (bool): whether use case is compatible with flash3 backend.
+
+    """
+    target_fn = partial(log_or_raise_error, raise_error=raise_error)
+
+    if not FLASH3_SUPPORTED:
+        target_fn(
+            "Flash Attention v3 (flash3) is not supported in this environment. Run with debug logs to find out why, or choose another backend.",
+            exception=RuntimeError,
+        )
+        return False
+
+    if is_torch_compiling():
+        target_fn(
+            "Flash Attention v3 (flash3) backend does not support torch.compile yet.",
+            exception=RuntimeError,
+        )
+        return False
+
+    arch_tag = get_arch_tag(query.device)
+    fwd_dtypes = get_fwd_dtypes(arch_tag)
+    bwd_dtypes = get_bwd_dtypes(arch_tag)
+    if not attention_tensor_checks(
+        query=query,
+        key=key,
+        value=value,
+        supported_dtypes_forward=fwd_dtypes,
+        supported_dtypes_backward=bwd_dtypes,
+        # flash3 supports MLA, unlike flash2, but with some constraints
+        # disabled for now due to API bug
+        supports_mla=False,
+        supports_gqa_mqa=True,
+        raise_error=raise_error,
+        backend_name="Flash Attention v3 (flash3)",
+    ):
+        target_fn("Flash Attention v3 (flash3) does not support the given inputs.", exception=RuntimeError)
+        return False
+
+    # MLA constraints
+    if query.shape[-1] != value.shape[-1]:
+        head_dim_q = query.shape[-1]
+        head_dim_v = value.shape[-1]
+        if not ((head_dim_q <= 64 and head_dim_v <= 512) or (128 <= head_dim_q <= 192 and 96 <= head_dim_v <= 128)):
+            target_fn(
+                "Flash Attention v3 (flash3) does not support this head dim combination. "
+                "Expected either head_dim_qk <= 64 and head_dim_v <= 512, or 128 <= head_dim_qk <= 192 "
+                f"and 96 <= head_dim_v <= 128, got {head_dim_q=}, {head_dim_v=}.",
+                exception=ValueError,
+            )
+            return False
+
+    # Verifies causal_type is a CausalType instance when is_causal
+    # Verifies DontCare is not used unless seqlen_q == seqlen_kv
+    attention_param_checks(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+    )
+
+    if is_causal and causal_type not in [CausalType.BottomRight, CausalType.DontCare]:
+        target_fn("Flash Attention only supports bottom-right causal masking.", exception=ValueError)
+        return False
+
+    return True

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash3/functions.py

@@ -0,0 +1,184 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Flash Attention v3 (flash3) Backend: intermediate APIs
+Only safe to import when FLASH3_SUPPORTED is True.
+"""
+
+import inspect
+
+from flash_attn_3.flash_attn_interface import flash_attn_func, flash_attn_varlen_func
+from torch import Tensor
+
+# NOTE: older commits didn't have `return_attn_probs` as an argument, and there is no
+# reflection of the commit hash in the version, so we have to manually inspect the signatures
+HAS_RETURN_ATTN_PROBS = "return_attn_probs" in inspect.signature(flash_attn_func).parameters
+
+from cosmos_policy._src.imaginaire.attention.flash3.checks import flash3_attention_check
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+
+
+def flash3_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool = False,
+    causal_type: CausalType | None = None,
+    scale: float | None = None,
+    cumulative_seqlen_Q: Tensor | None = None,
+    cumulative_seqlen_KV: Tensor | None = None,
+    max_seqlen_Q: int | None = None,
+    max_seqlen_KV: int | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    """
+    Runs Flash Attention v3 on given operands (Q, K, V) with the heads-last contiguous layout
+        (`[batch, seqlen, heads, head_dim]`).
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`)
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`)
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`)
+
+        is_causal (bool): whether or not causal masking is enabled. Default is False.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`. Required when `is_causal = True`.
+
+        scale (float | None): Dot product scale (attention scale). Defaults to head_dim ** -0.5.
+
+        cumulative_seqlen_Q (Tensor | None): (varlen) Optional 1-D tensor with size `batch + 1`
+            indicating the cumulative sum of number of query tokens in each batch, with an
+            additional 0 element in the beginning. Must be passed together with
+            `cumulative_seqlen_KV` and `max_seqlen_{Q,KV}`.
+
+        cumulative_seqlen_KV (Tensor | None): (varlen) Optional 1-D tensor with size `batch + 1`
+            indicating the cumulative sum of number of key/value tokens in each batch, with an
+            additional 0 element in the beginning. Must be passed together with
+            `cumulative_seqlen_Q` and `max_seqlen_{Q,KV}`.
+
+        max_seqlen_Q (int | None): (varlen) Optional integer indicating the maximum query
+            sequence length in all batches. Must be passed together with `cumulative_seqlen_{Q,KV}`
+            and `max_seqlen_KV`.
+
+        max_seqlen_KV (int | None): (varlen) Optional integer indicating the maximum key/value
+            sequence length in all batches. Must be passed together with `cumulative_seqlen_{Q,KV}`
+            and `max_seqlen_Q`.
+
+    Other Parameters:
+        return_lse (bool): Whether to return the logsumexp values. Default is False.
+
+        backend_kwargs (dict | None): Key-value pair for passing arguments specific to Flash's
+            attention operator, if any.
+
+    Returns:
+        output (Tensor): 4-D output tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim_v]`).
+
+        logsumexp (Tensor): logsumexp tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, 1]`). Only returned when return_lse is True.
+    """
+
+    is_varlen = cumulative_seqlen_Q is not None
+    assert flash3_attention_check(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+        is_varlen=is_varlen,
+        raise_error=True,
+    )
+
+    scale = scale if scale is not None else query.shape[-1] ** -0.5
+
+    backend_kwargs = backend_kwargs if backend_kwargs is not None else {}
+
+    if HAS_RETURN_ATTN_PROBS:
+        backend_kwargs["return_attn_probs"] = True
+
+    if is_varlen:
+        assert query.shape[0] == key.shape[0] == value.shape[0] == 1
+        q = query.squeeze(0)
+        k = key.squeeze(0)
+        v = value.squeeze(0)
+        assert q.dim() == k.dim() == v.dim() == 3
+        out, lse_ = flash_attn_varlen_func(
+            q=query.squeeze(0),
+            k=key.squeeze(0),
+            v=value.squeeze(0),
+            cu_seqlens_q=cumulative_seqlen_Q,
+            cu_seqlens_k=cumulative_seqlen_KV,
+            max_seqlen_q=max_seqlen_Q,
+            max_seqlen_k=max_seqlen_KV,
+            softmax_scale=scale,
+            causal=is_causal,
+            **backend_kwargs,
+            # qv=None,
+            # q_descale=None, k_descale=None, v_descale=None,
+            # attention_chunk=0,
+            # num_splits=1,
+            # pack_gqa=None,
+            # sm_margin=0,
+            # window_size=(-1, -1),
+            # softcap=0.0, # 0.0 means deactivated
+            # deterministic=False,
+        )
+        assert out.dim() == 3
+        assert lse_.dim() == 2
+
+        output = out.unsqueeze(0)
+        lse = lse_.unsqueeze(0)
+
+    else:
+        output, lse = flash_attn_func(
+            q=query,
+            k=key,
+            v=value,
+            softmax_scale=scale,
+            causal=is_causal,
+            **backend_kwargs,
+            # qv=None,
+            # q_descale=None, k_descale=None, v_descale=None,
+            # attention_chunk=0,
+            # num_splits=1,
+            # pack_gqa=None,
+            # sm_margin=0,
+            # window_size=(-1, -1),
+            # softcap=0.0, # 0.0 means deactivated
+            # deterministic=False,
+        )
+
+    assert isinstance(output, Tensor)
+    assert isinstance(lse, Tensor)
+    assert output.dim() == 4
+    assert lse.dim() == 3
+
+    lse = lse.permute(0, 2, 1).contiguous()  # [batch, seqlen, head_dim]
+
+    if return_lse:
+        return output, lse
+
+    return output

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash3/meta.py

@@ -0,0 +1,64 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Flash Attention v3 (flash3) Backend: metadata
+Always safe to import (as long as torch is available.)
+"""
+
+import torch
+
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+
+def get_fwd_dtypes(arch_tag: int) -> list[torch.dtype]:
+    """
+    Returns data type choices for forward pass according to arch tag (attention.utils.get_arch_tag).
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        data_type_choices (list): a list of PyTorch data types. Empty if device is not supported.
+
+    """
+
+    if arch_tag != 90:
+        log.debug("Flash Attention v3 (flash3) only supports compute capability 9.0 (Hopper).")
+        return []
+
+    return [torch.float16, torch.bfloat16]
+
+
+def get_bwd_dtypes(arch_tag: int) -> list[torch.dtype]:
+    """
+    Returns data type choices for backward pass according to arch tag (attention.utils.get_arch_tag).
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        data_type_choices (list): a list of PyTorch data types. Empty if device is not supported.
+
+    """
+
+    if arch_tag != 90:
+        log.debug("Flash Attention v3 (flash3) only supports compute capability 9.0 (Hopper).")
+        return []
+
+    return [torch.float16, torch.bfloat16]

REGEN-main/cosmos_policy/_src/imaginaire/attention/flash3/stubs.py

@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Flash Attention v3 (flash3) Backend: intermediate API stubs
+Always safe to import (as long as torch is available.)
+"""
+
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+
+
+def flash3_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool = False,
+    causal_type: CausalType | None = None,
+    scale: float | None = None,
+    cumulative_seqlen_Q: Tensor | None = None,
+    cumulative_seqlen_KV: Tensor | None = None,
+    max_seqlen_Q: int | None = None,
+    max_seqlen_KV: int | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    raise RuntimeError(
+        "Tried to run Flash Attention v3, but it is not supported / available. "
+        "Try running with debug logs enabled to see why."
+    )

REGEN-main/cosmos_policy/_src/imaginaire/attention/frontend.py

@@ -0,0 +1,587 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Frontend APIs
+"""
+
+import torch
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.backends import choose_backend, choose_multi_dim_backend
+from cosmos_policy._src.imaginaire.attention.checks import (
+    attention_param_checks,
+    attention_tensor_checks,
+    multi_dim_attention_param_checks,
+    multi_dim_attention_param_filter,
+    multi_dim_attention_tensor_checks,
+    varlen_tensor_checks,
+)
+from cosmos_policy._src.imaginaire.attention.cudnn import cudnn_attention
+from cosmos_policy._src.imaginaire.attention.flash2 import flash2_attention
+from cosmos_policy._src.imaginaire.attention.flash3 import flash3_attention
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.natten import natten_attention, natten_multi_dim_attention
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+# Map backend names to their frontend attention API
+BACKEND_MAP = {
+    "cudnn": cudnn_attention,
+    "natten": natten_attention,
+    "flash2": flash2_attention,
+    "flash3": flash3_attention,
+}
+
+MULTI_DIM_BACKEND_MAP = {
+    "natten": natten_multi_dim_attention,
+}
+
+
+def attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool = False,
+    causal_type: CausalType | None = None,
+    scale: float | None = None,
+    # varlen parameters
+    seqlens_Q: Tensor | None = None,
+    seqlens_KV: Tensor | None = None,
+    cumulative_seqlen_Q: Tensor | None = None,
+    cumulative_seqlen_KV: Tensor | None = None,
+    max_seqlen_Q: int | None = None,
+    max_seqlen_KV: int | None = None,
+    # backend & misc parameters
+    backend: str | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    """
+    Runs Attention on given operands (Q, K, V) with the heads-last contiguous layout
+        (`[batch, seqlen, heads, head_dim]`).
+
+    Varlen Attention is only supported for the sequence-packed layout: QKV tensors have batch size
+    1, and tokens from different batches are concatenated without any padding along the sequence
+    dimension. Sequence lengths for different batches can be provided in two ways:
+        1. `seqlens_Q` and `seqlens_KV` (less efficient): only provide the sequence lengths as
+            integer tensors (must be on the same device as QKV), and cumulative and maximum sequence
+            lengths are recomputed on each call.
+        2. `cumulative_seqlen_{Q,KV}` and `max_seqlen_{Q,KV}` (more efficient):
+            compute cumulative and maximum sequence lengths. `cumulative_seqlen_{Q,KV}` are integer
+            tensors on the same device as QKV containing the cumulative sum of `seqlens_{Q,KV}`,
+            with an additional `0` element in the beginning, therefore sized `batch+1`.
+            `max_seqlen_{Q,KV}` are integers (not Tensors) that represent the maximum sequence
+            lengths for Q and KV among all sequence batches.
+            You can use `generate_varlen_parameters` to generate these
+            parameters:
+                ```python3
+                from cosmos_policy._src.imaginaire.attention.varlen import generate_varlen_parameters
+                (
+                    cumulative_seqlen_Q,
+                    cumulative_seqlen_KV,
+                    max_seqlen_Q,
+                    max_seqlen_KV,
+                ) = generate_varlen_parameters(q, k, v, seqlens_Q, seqlens_KV)
+                ```
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_q, heads, head_dim]`)
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`)
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`)
+
+        is_causal (bool): whether or not causal masking is enabled. Default is False.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`, `CausalType.DontCare` (only valid when seqlen_q == seqlen_kv).
+            Required when `is_causal = True`.
+
+        scale (float | None): Dot product scale (attention scale). Defaults to head_dim ** -0.5.
+
+        seqlens_Q (Tensor | None): (varlen) Optional 1-D tensor with size `batch`
+            indicating the number of query tokens in each batch. Must be passed together with
+            `seqlens_KV`.
+
+        seqlens_KV (Tensor | None): (varlen) Optional 1-D tensor with size `batch`
+            indicating the number of key/value tokens in each batch. Must be passed together with
+            `seqlens_Q`.
+
+        cumulative_seqlen_Q (Tensor | None): (varlen) Optional 1-D tensor with size `batch + 1`
+            indicating the cumulative sum of number of query tokens in each batch, with an
+            additional 0 element in the beginning. Must be passed together with
+            `cumulative_seqlen_KV` and `max_seqlen_{Q,KV}`.
+
+        cumulative_seqlen_KV (Tensor | None): (varlen) Optional 1-D tensor with size `batch + 1`
+            indicating the cumulative sum of number of key/value tokens in each batch, with an
+            additional 0 element in the beginning. Must be passed together with
+            `cumulative_seqlen_Q` and `max_seqlen_{Q,KV}`.
+
+        max_seqlen_Q (int | None): (varlen) Optional integer indicating the maximum query
+            sequence length in all batches. Must be passed together with `cumulative_seqlen_{Q,KV}`
+            and `max_seqlen_KV`.
+
+        max_seqlen_KV (int | None): (varlen) Optional integer indicating the maximum key/value
+            sequence length in all batches. Must be passed together with `cumulative_seqlen_{Q,KV}`
+            and `max_seqlen_Q`.
+
+    Other Parameters:
+        backend (str | None): Backend to run with. If unspecified (default), it will try to
+            select the best available.
+
+        return_lse (bool): Whether to return the logsumexp values. Default is False.
+
+        backend_kwargs (dict | None): Key-value pair for passing arguments specific to the backend's
+            attention operator, if any. Only valid when a specific backend is selected (backend is
+            not None).
+
+    Returns:
+        output (Tensor): 4-D output tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_q, heads, head_dim_v]`).
+
+        logsumexp (Tensor): logsumexp tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_q, heads, 1]`). Only returned when return_lse is True.
+    """
+
+    assert attention_tensor_checks(query=query, key=key, value=value, raise_error=True)
+
+    attention_param_checks(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+    )
+
+    (
+        cumulative_seqlen_Q,
+        cumulative_seqlen_KV,
+        max_seqlen_Q,
+        max_seqlen_KV,
+    ) = varlen_tensor_checks(
+        query=query,
+        key=key,
+        value=value,
+        seqlens_Q=seqlens_Q,
+        seqlens_KV=seqlens_KV,
+        cumulative_seqlen_Q=cumulative_seqlen_Q,
+        cumulative_seqlen_KV=cumulative_seqlen_KV,
+        max_seqlen_Q=max_seqlen_Q,
+        max_seqlen_KV=max_seqlen_KV,
+    )
+    is_varlen = cumulative_seqlen_Q is not None
+
+    scale = scale if scale is not None else query.shape[-1] ** -0.5
+
+    if backend is None and backend_kwargs is not None:
+        backend_kwargs = None
+        log.debug("A backend was not specified, but got backend_kwargs. Ignoring... ")
+
+    if backend is not None and backend not in BACKEND_MAP:
+        raise ValueError(f"Selected {backend=}, but available choices are {BACKEND_MAP.keys()}. ")
+
+    compatible_backend = choose_backend(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+        is_varlen=is_varlen,
+        backend=backend,
+        raise_error=False,
+    )
+
+    # Either incompatible backend specified by user, or no compatible backends found
+    # Try to see if we can handle it with graph transformations
+    # For now only handling GQA/MQA, but MLA, varlen, and some other features are also
+    # implementable with graph transformations, but we may need them even if not as efficient.
+    if compatible_backend is None:
+        is_gqa_mqa = query.shape[-2] != key.shape[-2] and query.shape[-2] > key.shape[-2]
+
+        # In practice this is the only reason why no backend would be selected,
+        # but moving forward we should represent support matrices for backends explicitly
+        # and rely on reasons to make the best decision when it comes to graph transformations.
+        if is_gqa_mqa:
+            heads = query.shape[-2]
+            heads_kv = key.shape[-2]
+            assert heads % heads_kv == 0
+            h_k = heads // heads_kv
+
+            query_t = query
+            key_t = torch.repeat_interleave(key, repeats=h_k, dim=-2, output_size=heads)
+            value_t = torch.repeat_interleave(value, repeats=h_k, dim=-2, output_size=heads)
+
+            log.debug("Backend incompatible with GQA/MQA use case. Trying again with graph transformation... ")
+            return attention(
+                query=query_t,
+                key=key_t,
+                value=value_t,
+                is_causal=is_causal,
+                causal_type=causal_type,
+                scale=scale,
+                cumulative_seqlen_Q=cumulative_seqlen_Q,
+                cumulative_seqlen_KV=cumulative_seqlen_KV,
+                max_seqlen_Q=max_seqlen_Q,
+                max_seqlen_KV=max_seqlen_KV,
+                return_lse=return_lse,
+                backend=backend,
+                backend_kwargs=backend_kwargs,
+            )
+
+        if backend is None:
+            raise ValueError(
+                "Could not find a compatible Attention backend for this use case / device. "
+                "Try running with debug logs to find out why."
+            )
+        else:
+            raise ValueError(
+                f"Selected Attention backend {backend} is incompatible with this use case / device. "
+                "Try running with debug logs to find out why."
+            )
+
+    assert compatible_backend in BACKEND_MAP
+    return BACKEND_MAP[compatible_backend](
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+        scale=scale,
+        cumulative_seqlen_Q=cumulative_seqlen_Q,
+        cumulative_seqlen_KV=cumulative_seqlen_KV,
+        max_seqlen_Q=max_seqlen_Q,
+        max_seqlen_KV=max_seqlen_KV,
+        return_lse=return_lse,
+        backend_kwargs=backend_kwargs,
+    )
+
+
+def multi_dimensional_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    window_size: tuple | int = -1,
+    stride: tuple | int = 1,
+    dilation: tuple | int = 1,
+    is_causal: tuple | bool = False,
+    scale: float | None = None,
+    # backend & misc parameters
+    backend: str | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    """
+    Runs Multi-Dimensional Attention on given operands (Q, K, V) with the heads-last contiguous
+    layout (`[batch, *, heads, head_dim]`). Supports up to and including 3 dimensions:
+        * 1-D: `[batch, X, heads, head_dim]`, with masking arguments expecting tuples of size 1.
+        * 2-D: `[batch, X, Y, heads, head_dim]`, with masking arguments expecting tuples of size 2.
+        * 3-D: `[batch, X, Y, Z, heads, head_dim]`, with masking arguments expecting tuples of size 3.
+
+    The dimensions here refer to the layout of tokens; that is the arrangement of tokens for each
+    batch/head, or the `[X]`, `[X, Y]`, `[X, Y, Z]` part of the input shape.
+    We refer to these as the "token layout shape".
+
+    For now, it is always expected that Q, K, and V match in the sizes of those dimensions.
+
+    Masking arguments, all of which can be set uniformly across all dimensions or per dimension, are:
+        * `window_size`: determines the sliding window size. -1 is interpreted as the maximum window
+            size. Must be either -1 or at least 2 and at most the token layout shape.
+            For example, if inputs are `[batch, X, Y, Z, heads_{q,kv}, head_dim_{qk,v}]`,
+            `window_size` must be either an integer == -1 or an integer <= `min(X, Y, Z)`,
+            or a tuple of size 3 corresponding to the three dimensions / axes, where:
+                * `window_size[0] == -1 or 2 <= window_size[0] <= X`
+                * `window_size[1] == -1 or 2 <= window_size[1] <= Y`
+                * `window_size[2] == -1 or 2 <= window_size[2] <= Z`
+            When `window_size` is set to the maximum for any dimension, we're effectively performing
+            self attention (no sparsity) along that dimension.
+            Default is -1 (self attention).
+
+        * `stride`: determines the step size of the sliding window. Only matters when the
+            corresponding `window_size` is not -1 / maximum (self attention).
+            Default is 1, indicating the smallest sliding window delay.
+            Larger values trade off translational equivariance for potentially improved efficiency.
+            Maximum value for `stride` along each dimension is the corresponding `window_size`.
+            If `stride == window_size` along any dimension, it is equivalent to blocked / windowed
+            attention (from works such as Swin Transformer, SAM, ViTDet, etc) along that dimension,
+            meaning no overlap between windows.
+            For more details, please refer to the GNA paper:
+            https://arxiv.org/abs/2504.16922
+
+        * `dilation`: introduces gaps between tokens in a sliding window, similarly to dilated
+            convolution.
+            Default is 1, indicating no gaps.
+            Maximum value is the largest positive integer that satisfies
+            `window_size * dilation <= token_layout_shape` along that dimension.
+            Higher dilation means more sparse and global context. Lower dilation means more
+            locality.
+            For more details, please refer to the DiNAT paper:
+            https://arxiv.org/abs/2209.15001
+
+        * `is_causal`: per-dimension causal mask.
+
+    Parameters:
+        query (Tensor): 4-D, 5-D, or 6-D query tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads, head_dim]`)
+
+        key (Tensor): 4-D, 5-D, or 6-D key tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim]`)
+
+        value (Tensor): 4-D, 5-D, or 6-D value tensor, with heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim_v]`)
+
+        window_size (tuple | int): Attention window (kernel) size / shape. If an
+            integer, it will be repeated for all dimensions. For example `window_size=3`, when
+            `len(token_layout_shape) == 3`, is interpreted as `window_size=(3, 3, 3)`.
+            `-1`s are replaced with the corresponding `token_layout_shape`.
+            Final window size must satisfy `2 <= window_size <= token_layout_shape`.
+            Default is -1 (no sparsity).
+
+        stride (tuple | int): Sliding window step size/shape. If an integer, it will be repeated
+            for all dimensions. For example `stride=2`, when `len(token_layout_shape) == 3`, is
+            interpreted as `stride=(2, 2, 2)`.
+            Final stride must satisfy `1 <= stride <= window_size`.
+            Default is 1.
+
+        dilation (tuple | int): Dilation step size/shape. If an integer, it will be repeated for
+            all dimensions. For example `dilation=4`, when `len(token_layout_shape) == 3`, is
+            interpreted as `dilation=(4, 4, 4)`.
+            Final dilation must satisfy `2 <= dilation * window_size <= token_layout_shape`.
+            Default is 1.
+
+        is_causal (tuple | bool): Toggle causal masking. If a boolean, it will be repeated for all
+            dimensions. For example `is_causal=True`, when `len(token_layout_shape) == 3`, is
+            interpreted as `is_causal=(True, True, True)`.
+            Default is False.
+
+        scale (float | None): Dot product scale (attention scale). Defaults to head_dim ** -0.5.
+
+    Other Parameters:
+        backend (str | None): Backend to run with. If unspecified (default), it will try to
+            select the best available.
+
+        return_lse (bool): Whether to return the logsumexp values. Default is False.
+
+        backend_kwargs (dict | None): Key-value pair for passing arguments specific to the backend's
+            multi-dim / sparse attention operator, if any. Only valid when a specific backend is
+            selected (backend is not None).
+
+    Returns:
+        output (Tensor): 4-D, 5-D, or 6-D output tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads, head_dim_v]`).
+
+        logsumexp (Tensor): logsumexp tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads, 1]`). Only returned when return_lse is True.
+    """
+
+    assert multi_dim_attention_tensor_checks(query=query, key=key, value=value, raise_error=True)
+
+    token_layout_shape, window_size, stride, dilation, is_causal = multi_dim_attention_param_filter(
+        query,
+        window_size=window_size,
+        stride=stride,
+        dilation=dilation,
+        is_causal=is_causal,
+    )
+    num_dims = len(token_layout_shape)
+
+    # Automatic transformation for 1s in token layout
+    # I.e. Attention over a (1, 16, 32) token layout is identical to over a (16, 32)
+    # NOTE: assumes QKV token layouts match
+    token_layout_ones = [i for i in range(num_dims) if token_layout_shape[i] == 1]
+    if len(token_layout_ones) > 0:
+        token_layout_t = tuple(s for i, s in enumerate(token_layout_shape) if i not in token_layout_ones)
+        window_size_t = tuple(w for i, w in enumerate(window_size) if i not in token_layout_ones)
+        stride_t = tuple(s for i, s in enumerate(stride) if i not in token_layout_ones)
+        dilation_t = tuple(d for i, d in enumerate(dilation) if i not in token_layout_ones)
+        is_causal_t = tuple(c for i, c in enumerate(is_causal) if i not in token_layout_ones)
+
+        assert all(x >= 2 for x in token_layout_t)
+        assert all(w >= 2 for w in window_size_t)
+
+        query_t = query.reshape(query.shape[0], *token_layout_t, query.shape[-2], query.shape[-1])
+        key_t = key.reshape(key.shape[0], *token_layout_t, key.shape[-2], key.shape[-1])
+        value_t = key.reshape(value.shape[0], *token_layout_t, value.shape[-2], value.shape[-1])
+
+        log.debug(
+            "This Multi-Dimensional Attention problem has 1s in the token layout, which can be simplified from "
+            f"<{token_layout_shape=}, {window_size=}, {stride=}, {dilation=}, {is_causal=}> into "
+            f"<{token_layout_t=}, {window_size_t=}, {stride_t=}, {dilation_t=}, {is_causal_t=}>."
+        )
+
+        return multi_dimensional_attention(
+            query=query_t,
+            key=key_t,
+            value=value_t,
+            window_size=window_size_t,
+            stride=stride_t,
+            dilation=dilation_t,
+            is_causal=is_causal_t,
+            scale=scale,
+            backend=backend,
+            return_lse=return_lse,
+            backend_kwargs=backend_kwargs,
+        )
+
+    multi_dim_attention_param_checks(
+        query,
+        window_size=window_size,
+        stride=stride,
+        dilation=dilation,
+        is_causal=is_causal,
+    )
+
+    # Fast path for self attention problems
+    if all(x == w for x, w in zip(token_layout_shape, window_size)) and (
+        not any(c for c in is_causal) or num_dims == 1
+    ):
+        log.debug(
+            "This Multi-Dimensional Attention problem is implementable with standard Attention: "
+            f"{token_layout_shape=}, {window_size=}, {is_causal=}."
+        )
+        if backend is not None:
+            log.debug(f"Ignoring {backend=} and backend args...")
+
+        query_1d = query.flatten(1, num_dims)
+        key_1d = key.flatten(1, num_dims)
+        value_1d = value.flatten(1, num_dims)
+        is_causal_1d = is_causal[0]
+
+        return attention(
+            query_1d,
+            key_1d,
+            value_1d,
+            scale=scale,
+            is_causal=is_causal_1d,
+            causal_type=CausalType.DontCare,
+            return_lse=return_lse,
+        )
+
+    scale = scale if scale is not None else query.shape[-1] ** -0.5
+
+    if backend is None and backend_kwargs is not None:
+        backend_kwargs = None
+        log.debug("A backend was not specified, but got backend_kwargs. Ignoring... ")
+
+    backend = choose_multi_dim_backend(
+        query=query,
+        key=key,
+        value=value,
+        backend=backend,
+    )
+
+    if backend not in MULTI_DIM_BACKEND_MAP:
+        raise ValueError(f"Selected {backend=}, but available choices are {MULTI_DIM_BACKEND_MAP.keys()}. ")
+
+    return MULTI_DIM_BACKEND_MAP[backend](
+        query=query,
+        key=key,
+        value=value,
+        window_size=window_size,
+        stride=stride,
+        dilation=dilation,
+        is_causal=is_causal,
+        scale=scale,
+        return_lse=return_lse,
+        backend_kwargs=backend_kwargs,
+    )
+
+
+def spatio_temporal_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    window_size: tuple | int = -1,
+    stride: tuple | int = 1,
+    dilation: tuple | int = 1,
+    scale: float | None = None,
+    # backend & misc parameters
+    backend: str | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    """
+    Runs Spatio-Temporal Attention on unflattened QKV with the heads-last contiguous layout
+    (`[batch, T, H, W, heads, head_dim]`).
+    For now, it is always expected that Q, K, and V match in their shapes.
+
+    Parameters:
+        query (Tensor): 6-D query tensor, with the heads-last contiguous layout
+            (`[batch, T, H, W, heads, head_dim]`)
+
+        key (Tensor): 6-D key tensor, with the heads-last contiguous layout
+            (`[batch, T, H, W, heads_kv, head_dim]`)
+
+        value (Tensor): 6-D value tensor, with heads-last contiguous layout
+            (`[batch, T, H, W, heads_kv, head_dim_v]`)
+
+        window_size (tuple | int): Attention window (kernel) size / shape. If an
+            integer, it will be repeated for all dimensions. For example `window_size=3` is
+            interpreted as `window_size=(3, 3, 3)`.
+            `-1`s are replaced with the corresponding value in `(T, H, W)`.
+            Default is -1 (no sparsity).
+
+        stride (tuple | int): Sliding window step size/shape. If an integer, it will be repeated
+            for all dimensions. For example `stride=2` is interpreted as `stride=(2, 2, 2)`.
+            Final stride must satisfy `1 <= stride <= window_size`.
+            Default is 1.
+
+        dilation (tuple | int): Dilation step size/shape. If an integer, it will be repeated for
+            all dimensions. For example `dilation=4` is interpreted as `dilation=(4, 4, 4)`.
+            Final dilation must satisfy `2 <= dilation * window_size <= (T, H, W)`.
+            Default is 1.
+
+        scale (float | None): Dot product scale (attention scale). Defaults to head_dim ** -0.5.
+
+    Other Parameters:
+        backend (str | None): Backend to run with. If unspecified (default), it will try to
+            select the best available.
+
+        return_lse (bool): Whether to return the logsumexp values. Default is False.
+
+        backend_kwargs (dict | None): Key-value pair for passing arguments specific to the backend's
+            multi-dim / sparse attention operator, if any. Only valid when a specific backend is
+            selected (backend is not None).
+
+    Returns:
+        output (Tensor): 6-D output tensor, with the heads-last contiguous layout
+            (`[batch, T, H, W, heads, head_dim_v]`).
+
+        logsumexp (Tensor): logsumexp tensor, with the heads-last contiguous layout
+            (`[batch, T, H, W, heads, 1]`). Only returned when return_lse is True.
+    """
+    if query.dim() != 6:
+        raise ValueError(
+            "Spatio-Temporal Attention requires 6-D input tensors ([batch, T, H, W, heads, head_dim]), "
+            f"got {query.shape=})."
+        )
+
+    return multi_dimensional_attention(
+        query=query,
+        key=key,
+        value=value,
+        window_size=window_size,
+        stride=stride,
+        dilation=dilation,
+        is_causal=(True, False, False),
+        scale=scale,
+        return_lse=return_lse,
+        backend_kwargs=backend_kwargs,
+    )

REGEN-main/cosmos_policy/_src/imaginaire/attention/masks.py

@@ -0,0 +1,61 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Mask utilities
+"""
+
+from enum import Enum
+
+
+class CausalType(Enum):
+    """
+    Different types of causal masking supported by backends of interest.
+    """
+
+    # Top-Left: Simplified: mask if q_idx < kv_idx
+    # CUTLASS / NATTEN default
+    # Q = 2, KV = 5:
+    # O____
+    # OO___
+    #
+    # Q = 5, KV = 2:
+    # O_
+    # OO
+    # OO
+    # OO
+    # OO
+    TopLeft = 0
+
+    # Bottom-right: mask if q_idx + KV - Q < kv_idx
+    # Flash Attention default
+    # Q = 2, KV = 5:
+    # OOOO_
+    # OOOOO
+    #
+    # Q = 5, KV = 2:
+    # __
+    # __
+    # __
+    # O_
+    # OO
+    BottomRight = 1
+
+    # When seqlen_q == seqlen_kv, we don't care about the causal type
+    # because top-left and bottom-right are equivalent
+    DontCare = 2

REGEN-main/cosmos_policy/_src/imaginaire/attention/natten/__init__.py

@@ -0,0 +1,95 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+NATTEN Backend
+"""
+
+import torch
+
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+NATTEN_MIN_RELEASE_VERSION = [0, 21, 5]
+# 0.21.5.dev1 patches some varlen issues
+# 0.21.5.dev2 adds torch compile support
+# 0.21.5.dev3 fixes a few compat issues for older torch versions
+NATTEN_MIN_DEV_VERSION = ([0, 21, 5], 3)
+
+
+def natten_supported() -> bool:
+    """
+    Returns whether NATTEN is supported in this environment.
+    Requirements are:
+        * Presence of CUDA Runtime (via PyTorch)
+        * Presence of NATTEN, meeting minimum version requirements
+
+    This check guards imports / dependencies on the NATTEN package.
+    """
+    if not torch.cuda.is_available():
+        log.debug("NATTEN Attention is not supported because PyTorch did not detect CUDA runtime.")
+        return False
+
+    try:
+        import natten
+
+    except ImportError:
+        log.debug("NATTEN Attention is not supported because the Python package was not found.")
+        return False
+    except Exception as e:
+        log.debug(f"NATTEN Attention is not supported because importing the Python package failed: {e}")
+        return False
+
+    natten_version_split = natten.__version__.split(".")
+    if len(natten_version_split) < 3 or len(natten_version_split) > 4:
+        log.debug(f"Unable to parse NATTEN version {natten.__version__}.")
+        return False
+
+    try:
+        natten_version = [int(x) for x in natten_version_split[:3]]
+        natten_version_dev = None
+        if len(natten_version_split) >= 4 and natten_version_split[3].startswith("dev"):
+            natten_version_dev = int(natten_version_split[3].replace("dev", ""))
+
+    except ValueError:
+        log.debug(f"Unable to parse NATTEN version as an int list: {natten.__version__}.")
+        return False
+
+    if (natten_version_dev is None and natten_version >= NATTEN_MIN_RELEASE_VERSION) or (
+        natten_version_dev is not None
+        and natten_version >= NATTEN_MIN_DEV_VERSION[0]
+        and natten_version_dev >= NATTEN_MIN_DEV_VERSION[1]
+    ):
+        return True
+
+    log.debug(
+        "NATTEN Attention is not supported due to insufficient NATTEN version "
+        f"{natten.__version__=}, expected at least {NATTEN_MIN_RELEASE_VERSION=}, "
+        f"or {NATTEN_MIN_DEV_VERSION=}."
+    )
+    return False
+
+
+NATTEN_SUPPORTED = natten_supported()
+
+if NATTEN_SUPPORTED:
+    from cosmos_policy._src.imaginaire.attention.natten.functions import natten_attention, natten_multi_dim_attention
+
+else:
+    from cosmos_policy._src.imaginaire.attention.natten.stubs import natten_attention, natten_multi_dim_attention
+
+__all__ = ["natten_attention", "natten_multi_dim_attention", "NATTEN_SUPPORTED"]

REGEN-main/cosmos_policy/_src/imaginaire/attention/natten/checks.py

@@ -0,0 +1,391 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+NATTEN backend checks
+"""
+
+from functools import partial
+
+import torch
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.checks import (
+    attention_param_checks,
+    attention_tensor_checks,
+    multi_dim_attention_tensor_checks,
+)
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.natten import NATTEN_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.natten.meta import get_bwd_dtypes, get_fwd_dtypes
+from cosmos_policy._src.imaginaire.attention.utils import get_arch_tag, log_or_raise_error
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+
+def dtype_supported(
+    dtype: torch.dtype, is_training: bool, dtypes_fwd: list[torch.dtype], dtypes_bwd: list[torch.dtype] | None = None
+) -> bool:
+    """
+    Helper determining whether dtype is supported with different sets of supported dtypes for
+    training and inference (forward+backward and forward).
+
+    Parameters:
+        dtype (torch.dtype): tensor element type.
+
+        is_training (bool): whether use case can be used to backpropagate (tensor.requires_grad).
+
+        dtypes_fwd (list[torch.dtype]): list of dtypes allowed for inference only (when not
+            tensor.requires_grad).
+
+        dtypes_bwd (list[torch.dtype] | None): Optional list of dtypes allowed for training only
+            (when tensor.requires_grad), if different from dtypes_fwd.
+
+    """
+    if is_training and dtypes_bwd is not None:
+        return dtype in dtypes_bwd
+    return dtype in dtypes_fwd
+
+
+def choose_natten_backend(
+    query: Tensor, key: Tensor, value: Tensor, is_causal: bool, is_varlen: bool, raise_error: bool = False
+) -> str | None:
+    """
+    Chooses an FMHA backend in NATTEN (cutlass-fmha, hopper-fmha, blackwell-fmha) for the current
+    use case based on features needed and current GPU architecture.
+
+    Using tensor shapes, it infers whether MLA (head_dim_value != head_dim_qk) or
+    GQA/MQA (heads_kv != heads_q) are required.
+    Using tensor device, it infers GPU architecture and compatible backends.
+    Using arguments is_causal and is_varlen, and other inferred features, it picks the best
+    available backend.
+
+    It is possible for no backend to be selected, if the combination of features is not available in
+    any one of the NATTEN backends, in which case it will return None.
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`).
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`).
+
+        is_causal (bool): whether or not causal masking is enabled.
+
+        is_varlen (bool): whether or not a variable length (varlen) use case. Must be inferred
+            beforehand based on arguments such as seqlens_{Q,KV} or cumulative_seqlen_{Q,KV} being
+            passed.
+
+        raise_error (bool): whether to raise an error if no backend is selected, instead of just
+            returning None. Default is False.
+
+    Returns:
+        backend (str | None): selected NATTEN backend, if any compatible.
+
+    """
+    target_fn = partial(log_or_raise_error, raise_error=raise_error)
+
+    # NOTE: assumes attention_tensor_checks have already been run once!
+    arch_tag = get_arch_tag(query.device)
+    dtype = query.dtype
+    is_training = query.requires_grad
+
+    is_mla = query.shape[-1] != value.shape[-1]
+    is_gqa_mqa = query.shape[-2] != key.shape[-2]
+
+    # banning devices not supported since CUDA 13.0 for simplicity
+    if arch_tag < 75:
+        log.debug("NATTEN is not supported because compute capability is below the minimum (7.5).")
+        return None
+
+    # blackwell-fmha: sm100 and sm103 only.
+    # limitations: no mla (TBD).
+    blackwell_fmha_fwd_dtypes = [torch.float16, torch.bfloat16, torch.float8_e5m2, torch.float8_e4m3fn]
+    blackwell_fmha_bwd_dtypes = [torch.float16, torch.bfloat16]
+    dtype_supported_blackwell = dtype_supported(
+        dtype=dtype, is_training=is_training, dtypes_fwd=blackwell_fmha_fwd_dtypes, dtypes_bwd=blackwell_fmha_bwd_dtypes
+    )
+    if arch_tag in [100, 103] and not is_mla and dtype_supported_blackwell:
+        return "blackwell-fmha"
+    else:
+        reason = ""
+        if arch_tag not in [100, 103]:
+            reason += f"Incompatible architecture ({arch_tag}, expected 100 or 103). "
+        if is_mla:
+            reason += "Use case is MLA (head_dim_qk != head_dim_value). "
+        if not dtype_supported_blackwell:
+            if is_training:
+                reason += (
+                    f"Data type {dtype} is not in list of supported dtypes for training: {blackwell_fmha_bwd_dtypes}. "
+                )
+            else:
+                reason += (
+                    f"Data type {dtype} is not in list of supported dtypes for inference: {blackwell_fmha_fwd_dtypes}. "
+                )
+        log.debug(f"NATTEN backend blackwell-fmha is not compatible. Reason: {reason}")
+
+    # hopper-fmha: sm90 only.
+    # limitations: no causal masking (TBD), no varlen, no gqa/mqa, no mla.
+    hopper_fmha_dtypes = [torch.float16, torch.bfloat16]
+    dtype_supported_hopper = dtype_supported(dtype=dtype, is_training=is_training, dtypes_fwd=hopper_fmha_dtypes)
+    if arch_tag == 90 and not is_causal and not is_varlen and not is_gqa_mqa and not is_mla and dtype_supported_hopper:
+        return "hopper-fmha"
+    else:
+        reason = ""
+        if arch_tag != 90:
+            reason += f"Incompatible architecture ({arch_tag}, expected 90). "
+        if is_causal:
+            reason += "Use case is causal. "
+        if is_varlen:
+            reason += "Use case is varlen. "
+        if is_gqa_mqa:
+            reason += "Use case is GQA/MQA. "
+        if is_mla:
+            reason += "Use case is MLA (head_dim_qk != head_dim_value). "
+        if not dtype_supported_hopper:
+            reason += f"Data type {dtype} is not in list of supported dtypes: {hopper_fmha_dtypes}. "
+        log.debug(f"NATTEN backend hopper-fmha is not compatible. Reason: {reason}")
+
+    # cutlass-fmha: targets sm50, sm70, sm75, sm80 (supports sm80+)
+    # limitations: no gqa/mqa.
+    cutlass_fmha_dtypes = [torch.float32, torch.float16, torch.bfloat16]
+    dtype_supported_cutlass = dtype_supported(dtype=dtype, is_training=is_training, dtypes_fwd=cutlass_fmha_dtypes)
+    if not is_gqa_mqa and dtype_supported_cutlass:
+        return "cutlass-fmha"
+    else:
+        reason = ""
+        if is_gqa_mqa:
+            reason += "Use case is GQA/MQA. "
+        if not dtype_supported_cutlass:
+            reason += f"Data type {dtype} is not in list of supported dtypes: {cutlass_fmha_dtypes}. "
+        log.debug(f"NATTEN backend cutlass-fmha is not compatible. Reason: {reason}")
+
+    target_fn(
+        f"Could not find a compatible NATTEN FMHA backend for {arch_tag=}, {is_causal=}, "
+        f"{is_varlen=}, {is_mla=}, {is_gqa_mqa=}.",
+        exception=RuntimeError,
+    )
+    return None
+
+
+def natten_attention_check(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool,
+    causal_type: CausalType,
+    is_varlen: bool,
+    raise_error: bool = False,
+) -> bool:
+    """
+    Input validation function for the NATTEN backend.
+    Runs the common checks in addition to trying to find a compatible NATTEN backend. If any checks
+    fail, or no compatible backend is found in NATTEN, returns False.
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`).
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`).
+
+        is_causal (bool): whether or not causal masking is enabled.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`. Required when `is_causal = True`.
+
+        is_varlen (bool): whether or not a variable length (varlen) use case. Must be inferred
+            beforehand based on arguments such as seqlens_{Q,KV} or cumulative_seqlen_{Q,KV} being
+            passed.
+
+        raise_error (bool): whether to raise an error if any checks fail or no backend is selected,
+            instead of just returning False. Default is False.
+
+    Returns:
+        success (bool): whether use case is compatible with NATTEN backend.
+
+    """
+    target_fn = partial(log_or_raise_error, raise_error=raise_error)
+
+    if not NATTEN_SUPPORTED:
+        target_fn(
+            "NATTEN is not supported in this environment. Run with debug logs to find out why, or choose another backend.",
+            exception=RuntimeError,
+        )
+        return False
+
+    arch_tag = get_arch_tag(query.device)
+    fwd_dtypes = get_fwd_dtypes(arch_tag)
+    bwd_dtypes = get_bwd_dtypes(arch_tag)
+    if not attention_tensor_checks(
+        query=query,
+        key=key,
+        value=value,
+        supported_dtypes_forward=fwd_dtypes,
+        supported_dtypes_backward=bwd_dtypes,
+        supports_mla=True,
+        supports_gqa_mqa=True,
+        raise_error=raise_error,
+        backend_name="NATTEN Attention",
+    ):
+        target_fn("NATTEN does not support the given inputs.", exception=RuntimeError)
+        return False
+
+    # Verifies causal_type is a CausalType instance when is_causal
+    # Verifies DontCare is not used unless seqlen_q == seqlen_kv
+    attention_param_checks(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+    )
+
+    if is_causal and causal_type not in [CausalType.TopLeft, CausalType.DontCare]:
+        target_fn("NATTEN Attention only supports top-left causal masking for now.", exception=RuntimeError)
+        return False
+
+    natten_backend = choose_natten_backend(
+        query, key, value, is_causal=is_causal, is_varlen=is_varlen, raise_error=raise_error
+    )
+
+    if natten_backend is None:
+        return False
+
+    return True
+
+
+def choose_natten_multi_dim_backend(query: Tensor, key: Tensor, value: Tensor, raise_error: bool = False) -> str | None:
+    """
+    Chooses an FNA backend in NATTEN (cutlass-fna, hopper-fna, blackwell-fna) for the current
+    use case based on features needed and current GPU architecture.
+
+    Using tensor shapes, it infers whether MLA (head_dim_value != head_dim_qk) or
+    GQA/MQA (heads_kv != heads_q) are required.
+    Using tensor device, it infers GPU architecture and compatible backends.
+    Using arguments is_causal and is_varlen, and other inferred features, it picks the best
+    available backend.
+
+    It is possible for no backend to be selected, if the combination of features is not available in
+    any one of the NATTEN backends, in which case it will return None.
+
+    Parameters:
+        query (Tensor): 4-D, 5-D, or 6-D query tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads, head_dim]`).
+
+        key (Tensor): 4-D, 5-D, or 6-D key tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D, 5-D, or 6-D value tensor, with heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim_v]`).
+
+        raise_error (bool): whether to raise an error if no backend is selected, instead of just
+            returning None. Default is False.
+
+    Returns:
+        backend (str | None): selected NATTEN backend, if any compatible.
+
+    """
+
+    # Reuse choose_natten_backend instead of duplicating code
+    # NATTEN specifically makes sure the FNA counterparts cover all the features the FMHA kernels
+    # do.
+    fmha_backend = choose_natten_backend(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=False,  # causal masking in supported across all multi-dim (FNA) backends
+        is_varlen=False,  # varlen is undefined (so far) for multi-dim
+        raise_error=raise_error,
+    )
+
+    natten_fmha_backend_to_fna_backend = {
+        "cutlass-fmha": "cutlass-fna",
+        "hopper-fmha": "hopper-fna",
+        "blackwell-fmha": "blackwell-fna",
+    }
+
+    assert fmha_backend in natten_fmha_backend_to_fna_backend
+    return natten_fmha_backend_to_fna_backend[fmha_backend]
+
+
+def natten_multi_dim_attention_check(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    raise_error: bool = False,
+) -> bool:
+    """
+    Input validation function for the NATTEN multi-dimensional backend.
+    Runs the common checks in addition to trying to find a compatible NATTEN backend. If any checks
+    fail, or no compatible backend is found in NATTEN, returns False.
+
+    Parameters:
+        query (Tensor): 4-D, 5-D, or 6-D query tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads, head_dim]`).
+
+        key (Tensor): 4-D, 5-D, or 6-D key tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim]`).
+
+        value (Tensor): 4-D, 5-D, or 6-D value tensor, with heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim_v]`).
+
+        raise_error (bool): whether to raise an error if any checks fail or no backend is selected,
+            instead of just returning False. Default is False.
+
+    Returns:
+        success (bool): whether use case is compatible with NATTEN backend.
+
+    """
+    target_fn = partial(log_or_raise_error, raise_error=raise_error)
+
+    if not NATTEN_SUPPORTED:
+        target_fn(
+            "NATTEN is not supported in this environment. Run with debug logs to find out why, or choose another backend.",
+            exception=RuntimeError,
+        )
+        return False
+
+    arch_tag = get_arch_tag(query.device)
+    fwd_dtypes = get_fwd_dtypes(arch_tag)
+    bwd_dtypes = get_bwd_dtypes(arch_tag)
+    if not multi_dim_attention_tensor_checks(
+        query=query,
+        key=key,
+        value=value,
+        supported_dtypes_forward=fwd_dtypes,
+        supported_dtypes_backward=bwd_dtypes,
+        supports_mla=True,
+        supports_gqa_mqa=False,  # NATTEN's FNA ops don't support GQA/MQA yet
+        raise_error=raise_error,
+        backend_name="NATTEN Multi-Dimensional Attention",
+    ):
+        target_fn("NATTEN does not support the given inputs.", exception=RuntimeError)
+        return False
+
+    natten_backend = choose_natten_multi_dim_backend(query, key, value, raise_error=raise_error)
+
+    if natten_backend is None:
+        return False
+
+    return True

REGEN-main/cosmos_policy/_src/imaginaire/attention/natten/functions.py

@@ -0,0 +1,293 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+NATTEN Backend: intermediate APIs
+Only safe to import when NATTEN_SUPPORTED is True.
+"""
+
+from natten.context import set_memory_usage_preference, use_kv_parallelism_in_fused_na
+from natten.functional import attention as _natten_attention
+from natten.functional import neighborhood_attention_generic as _natten_multi_dim_attention
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.checks import (
+    multi_dim_attention_param_checks,
+    multi_dim_attention_param_filter,
+)
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.natten.checks import (
+    choose_natten_backend,
+    choose_natten_multi_dim_backend,
+    natten_attention_check,
+    natten_multi_dim_attention_check,
+)
+
+set_memory_usage_preference("unrestricted")
+use_kv_parallelism_in_fused_na(True)
+
+
+def natten_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool = False,
+    causal_type: CausalType | None = None,
+    scale: float | None = None,
+    cumulative_seqlen_Q: Tensor | None = None,
+    cumulative_seqlen_KV: Tensor | None = None,
+    max_seqlen_Q: int | None = None,
+    max_seqlen_KV: int | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    """
+    Runs NATTEN Attention on given operands (Q, K, V) with the heads-last contiguous layout
+        (`[batch, seqlen, heads, head_dim]`).
+
+    Parameters:
+        query (Tensor): 4-D query tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim]`)
+
+        key (Tensor): 4-D key tensor, with the heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim]`)
+
+        value (Tensor): 4-D value tensor, with heads-last contiguous layout
+            (`[batch, seqlen_kv, heads_kv, head_dim_v]`)
+
+        is_causal (bool): whether or not causal masking is enabled. Default is False.
+
+        causal_type (CausalType): causal masking mode. Choices: `CausalType.TopLeft`,
+            `CausalType.BottomRight`. Required when `is_causal = True`.
+
+        scale (float | None): Dot product scale (attention scale). Defaults to head_dim ** -0.5.
+
+        cumulative_seqlen_Q (Tensor | None): (varlen) Optional 1-D tensor with size `batch + 1`
+            indicating the cumulative sum of number of query tokens in each batch, with an
+            additional 0 element in the beginning. Must be passed together with
+            `cumulative_seqlen_KV` and `max_seqlen_{Q,KV}`.
+
+        cumulative_seqlen_KV (Tensor | None): (varlen) Optional 1-D tensor with size `batch + 1`
+            indicating the cumulative sum of number of key/value tokens in each batch, with an
+            additional 0 element in the beginning. Must be passed together with
+            `cumulative_seqlen_Q` and `max_seqlen_{Q,KV}`.
+
+        max_seqlen_Q (int | None): (varlen) Optional integer indicating the maximum query
+            sequence length in all batches. Must be passed together with `cumulative_seqlen_{Q,KV}`
+            and `max_seqlen_KV`.
+
+        max_seqlen_KV (int | None): (varlen) Optional integer indicating the maximum key/value
+            sequence length in all batches. Must be passed together with `cumulative_seqlen_{Q,KV}`
+            and `max_seqlen_Q`.
+
+    Other Parameters:
+        return_lse (bool): Whether to return the logsumexp values. Default is False.
+
+        backend_kwargs (dict | None): Key-value pair for passing arguments specific to NATTEN's
+            attention operator, if any.
+
+    Returns:
+        output (Tensor): 4-D output tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, head_dim_v]`).
+
+        logsumexp (Tensor): logsumexp tensor, with the heads-last contiguous layout
+            (`[batch, seqlen, heads, 1]`). Only returned when return_lse is True.
+    """
+
+    is_varlen = cumulative_seqlen_Q is not None
+    assert natten_attention_check(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        causal_type=causal_type,
+        is_varlen=is_varlen,
+        raise_error=True,
+    )
+
+    scale = scale if scale is not None else query.shape[-1] ** -0.5
+
+    backend_kwargs = backend_kwargs.copy() if backend_kwargs is not None else {}
+
+    natten_backend = None
+    if "backend" in backend_kwargs:
+        natten_backend = backend_kwargs["backend"]
+        del backend_kwargs["backend"]
+    else:
+        natten_backend = choose_natten_backend(
+            query, key, value, is_causal=is_causal, is_varlen=is_varlen, raise_error=True
+        )
+
+    assert natten_backend is not None
+
+    # Override NATTEN's default delta reduction method: using PyTorch
+    # is more accurate, but slightly slower.
+    # Only affects NATTEN's "cutlass-fmha" backend (Ampere kernels)
+    backward_use_pt_reduction = True
+    if "backward_use_pt_reduction" in backend_kwargs:
+        backward_use_pt_reduction = backend_kwargs["backward_use_pt_reduction"]
+        del backend_kwargs["backward_use_pt_reduction"]
+
+    return _natten_attention(
+        query=query,
+        key=key,
+        value=value,
+        is_causal=is_causal,
+        scale=scale,
+        cumulative_seqlen_Q=cumulative_seqlen_Q,
+        cumulative_seqlen_KV=cumulative_seqlen_KV,
+        max_seqlen_Q=max_seqlen_Q,
+        max_seqlen_KV=max_seqlen_KV,
+        return_lse=return_lse,
+        backend=natten_backend,
+        backward_use_pt_reduction=backward_use_pt_reduction,
+        **backend_kwargs,
+    )
+
+
+def natten_multi_dim_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    window_size: tuple | int = -1,
+    stride: tuple | int = 1,
+    dilation: tuple | int = 1,
+    is_causal: tuple | bool = False,
+    scale: float | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    """
+    Runs NATTEN's Multi-Dimensional Attention on given operands (Q, K, V) with the heads-last
+    contiguous layout (`[batch, *, heads, head_dim]`). Supports up to and including 3 dimensions:
+        * 1-D: `[batch, X, heads, head_dim]`, with masking arguments expecting tuples of size 1.
+        * 2-D: `[batch, X, Y, heads, head_dim]`, with masking arguments expecting tuples of size 2.
+        * 3-D: `[batch, X, Y, Z, heads, head_dim]`, with masking arguments expecting tuples of size 3.
+
+    Parameters:
+        query (Tensor): 4-D, 5-D, or 6-D query tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads, head_dim]`)
+
+        key (Tensor): 4-D, 5-D, or 6-D key tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim]`)
+
+        value (Tensor): 4-D, 5-D, or 6-D value tensor, with heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads_kv, head_dim_v]`)
+
+        window_size (tuple | int): Attention window (kernel) size / shape. If an
+            integer, it will be repeated for all dimensions. For example `window_size=3`, when
+            `len(token_layout_shape) == 3`, is interpreted as `window_size=(3, 3, 3)`.
+            `-1`s are replaced with the corresponding `token_layout_shape`.
+            Final window size must satisfy `2 <= window_size <= token_layout_shape`.
+            Default is -1 (no sparsity).
+
+        stride (tuple | int): Sliding window step size/shape. If an integer, it will be repeated
+            for all dimensions.  For example `stride=2`, when `len(token_layout_shape) == 3`, is
+            interpreted as `stride=(2, 2, 2)`.
+            Final stride must satisfy `1 <= stride <= window_size`.
+            Default is 1.
+
+        dilation (tuple | int): Dilation step size/shape. If an integer, it will be repeated for
+            all dimensions. For example `dilation=4`, when `len(token_layout_shape) == 3`, is
+            interpreted as `dilation=(4, 4, 4)`.
+            Final dilation must satisfy `2 <= dilation * window_size <= token_layout_shape`.
+            Default is 1.
+
+        is_causal (tuple | bool): Toggle causal masking. If a boolean, it will be repeated for all
+            dimensions. For example `is_causal=True`, when `len(token_layout_shape) == 3`, is
+            interpreted as `is_causal=(True, True, True)`.
+            Default is False.
+
+        scale (float | None): Dot product scale (attention scale). Defaults to head_dim ** -0.5.
+
+    Other Parameters:
+        return_lse (bool): Whether to return the logsumexp values. Default is False.
+
+        backend_kwargs (dict | None): Key-value pair for passing arguments specific to NATTEN's
+            multi-dim / sparse attention operator, if any.
+
+    Returns:
+        output (Tensor): 4-D, 5-D, or 6-D output tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads, head_dim_v]`).
+
+        logsumexp (Tensor): logsumexp tensor, with the heads-last contiguous layout
+            (`[batch, *token_layout_shape, heads, 1]`). Only returned when return_lse is True.
+    """
+
+    assert natten_multi_dim_attention_check(
+        query=query,
+        key=key,
+        value=value,
+        raise_error=True,
+    )
+
+    token_layout, window_size, stride, dilation, is_causal = multi_dim_attention_param_filter(
+        query,
+        window_size=window_size,
+        stride=stride,
+        dilation=dilation,
+        is_causal=is_causal,
+    )
+
+    multi_dim_attention_param_checks(
+        query,
+        window_size=window_size,
+        stride=stride,
+        dilation=dilation,
+        is_causal=is_causal,
+    )
+
+    scale = scale if scale is not None else query.shape[-1] ** -0.5
+
+    backend_kwargs = backend_kwargs.copy() if backend_kwargs is not None else {}
+
+    natten_backend = None
+    if "backend" in backend_kwargs:
+        natten_backend = backend_kwargs["backend"]
+        del backend_kwargs["backend"]
+    else:
+        natten_backend = choose_natten_multi_dim_backend(query, key, value, raise_error=True)
+
+    assert natten_backend is not None
+
+    # Override NATTEN's default delta reduction method: using PyTorch
+    # is more accurate, but slightly slower.
+    # Only affects NATTEN's "cutlass-fmha" backend (Ampere kernels)
+    backward_use_pt_reduction = True
+    if "backward_use_pt_reduction" in backend_kwargs:
+        backward_use_pt_reduction = backend_kwargs["backward_use_pt_reduction"]
+        del backend_kwargs["backward_use_pt_reduction"]
+
+    output = _natten_multi_dim_attention(
+        query=query,
+        key=key,
+        value=value,
+        kernel_size=window_size,
+        stride=stride,
+        dilation=dilation,
+        is_causal=is_causal,
+        scale=scale,
+        backend=natten_backend,
+        backward_use_pt_reduction=backward_use_pt_reduction,
+        **backend_kwargs,
+    )
+
+    if return_lse:
+        raise NotImplementedError("NATTEN's Multi-Dimensional Attention does not support returning the logsumexp yet.")
+
+    return output

REGEN-main/cosmos_policy/_src/imaginaire/attention/natten/meta.py

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+NATTEN Backend: metadata
+Always safe to import (as long as torch is available.)
+"""
+
+import torch
+
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+
+def get_fwd_dtypes(arch_tag: int) -> list[torch.dtype]:
+    """
+    Returns data type choices for forward pass according to arch tag (attention.utils.get_arch_tag).
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        data_type_choices (list): a list of PyTorch data types. Empty if device is not supported.
+
+    """
+
+    if arch_tag < 75:
+        log.debug("NATTEN is not supported because compute capability is below the minimum (7.5).")
+        return []
+
+    if arch_tag in [100, 103]:
+        return [torch.float32, torch.float16, torch.bfloat16, torch.float8_e5m2, torch.float8_e4m3fn]
+
+    return [torch.float32, torch.float16, torch.bfloat16]
+
+
+def get_bwd_dtypes(arch_tag: int) -> list[torch.dtype]:
+    """
+    Returns data type choices for backward pass according to arch tag (attention.utils.get_arch_tag).
+
+    Parameters:
+        arch_tag (int): Arch tag for the current CUDA device. Example: 80 for A100, 90 for H100.
+
+    Returns:
+        data_type_choices (list): a list of PyTorch data types. Empty if device is not supported.
+
+    """
+
+    if arch_tag < 75:
+        log.debug("NATTEN is not supported because compute capability is below the minimum (7.5).")
+        return []
+
+    return [torch.float32, torch.float16, torch.bfloat16]

REGEN-main/cosmos_policy/_src/imaginaire/attention/natten/stubs.py

@@ -0,0 +1,64 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+NATTEN Backend: intermediate API stubs
+Always safe to import (as long as torch is available.)
+"""
+
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+
+
+def natten_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    is_causal: bool = False,
+    causal_type: CausalType | None = None,
+    scale: float | None = None,
+    cumulative_seqlen_Q: Tensor | None = None,
+    cumulative_seqlen_KV: Tensor | None = None,
+    max_seqlen_Q: int | None = None,
+    max_seqlen_KV: int | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    raise RuntimeError(
+        "Tried to run NATTEN attention, but it is not supported / available. "
+        "Try running with debug logs enabled to see why."
+    )
+
+
+def natten_multi_dim_attention(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    window_size: tuple | int = -1,
+    stride: tuple | int = 1,
+    dilation: tuple | int = 1,
+    is_causal: tuple | bool = False,
+    scale: float | None = None,
+    return_lse: bool = False,
+    backend_kwargs: dict | None = None,
+) -> Tensor | tuple[Tensor, Tensor]:
+    raise RuntimeError(
+        "Tried to run NATTEN's Multi-Dimensional attention, but it is not supported / available. "
+        "Try running with debug logs enabled to see why."
+    )

REGEN-main/cosmos_policy/_src/imaginaire/attention/tests/multi_dim_test.py

@@ -0,0 +1,503 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Multi-Dimensional Attention unit tests.
+"""
+
+import math
+import random
+import unittest
+from functools import partial
+from itertools import product
+from typing import Callable
+
+import pytest
+import torch
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention import multi_dimensional_attention
+from cosmos_policy._src.imaginaire.attention.natten import NATTEN_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.utils import is_blackwell_dc, is_fp8
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+RAND_SWEEP_TESTS = 1000
+
+skip_if_natten_not_supported = partial(
+    pytest.mark.skipif,
+    not NATTEN_SUPPORTED,
+    reason="NATTEN is disabled, not available, or too old in this environment.",
+)
+
+
+def _reset_everything():
+    torch.manual_seed(42)
+    torch.cuda.empty_cache()
+
+
+class MultiDimTester:
+    def __init__(
+        self,
+        reference_fn: Callable,
+        batch: int,
+        heads: int,
+        token_layout_shape: tuple,
+        head_dim: int,
+        window_size: tuple,
+        stride: tuple,
+        dilation: tuple,
+        is_causal: tuple,
+        test_backward: bool = True,
+        scale: float | None = None,
+        dtype: torch.dtype = torch.float32,
+        device: torch.device = "cuda",
+        heads_kv: int | None = None,
+        head_dim_v: int | None = None,
+    ):
+        self.batch = batch
+        self.heads = heads
+        self.heads_kv = heads_kv or heads
+        self.token_layout_shape = token_layout_shape
+        self.head_dim = head_dim
+        self.head_dim_v = head_dim_v or head_dim
+        self.test_backward = test_backward
+        self.scale = scale if scale is not None else head_dim**-0.5
+        self.dtype = dtype
+        self.device = device
+
+        self.window_size = window_size
+        self.stride = stride
+        self.dilation = dilation
+        self.is_causal = is_causal
+
+        # Initialize input tensors
+        self.q = torch.randn(
+            self.batch,
+            *self.token_layout_shape,
+            self.heads,
+            self.head_dim,
+            dtype=dtype,
+            device=device,
+            requires_grad=test_backward,
+        )
+        self.k = torch.randn(
+            self.batch,
+            *self.token_layout_shape,
+            self.heads_kv,
+            self.head_dim,
+            dtype=dtype,
+            device=device,
+            requires_grad=test_backward,
+        )
+        self.v = torch.randn(
+            self.batch,
+            *self.token_layout_shape,
+            self.heads_kv,
+            self.head_dim_v,
+            dtype=dtype,
+            device=device,
+            requires_grad=test_backward,
+        )
+        self.d_output = (
+            torch.randn(self.batch, *self.token_layout_shape, self.heads, self.head_dim_v, dtype=dtype, device=device)
+            if test_backward
+            else None
+        )
+
+        # Run reference implementation
+        q_ref = self.q.clone().detach().requires_grad_(self.test_backward)
+        k_ref = self.k.clone().detach().requires_grad_(self.test_backward)
+        v_ref = self.v.clone().detach().requires_grad_(self.test_backward)
+
+        output_ref = reference_fn(
+            query=q_ref,
+            key=k_ref,
+            value=v_ref,
+            scale=self.scale,
+            window_size=self.window_size,
+            stride=self.stride,
+            dilation=self.dilation,
+            is_causal=self.is_causal,
+        )
+
+        self.output_ref = output_ref.detach().to(torch.float32)
+
+        # Reference backward pass
+        if self.test_backward:
+            d_output = self.d_output.clone().detach()
+            output_ref.backward(d_output)
+            self.dq_ref = q_ref.grad.detach().to(torch.float32)
+            self.dk_ref = k_ref.grad.detach().to(torch.float32)
+            self.dv_ref = v_ref.grad.detach().to(torch.float32)
+
+    def test(
+        self,
+        target_fn: Callable,
+        dtype: torch.dtype,
+        atol_fwd: float,
+        atol_bwd: tuple[float, float, float] | None = None,
+        rtol_fwd: float = 0.0,
+        rtol_bwd: float = 0.0,
+        test_backward: bool | None = None,
+    ):
+        test_backward = self.test_backward if test_backward is None else test_backward
+
+        q = self.q.clone().detach().to(dtype).requires_grad_(test_backward)
+        k = self.k.clone().detach().to(dtype).requires_grad_(test_backward)
+        v = self.v.clone().detach().to(dtype).requires_grad_(test_backward)
+
+        output = target_fn(
+            query=q,
+            key=k,
+            value=v,
+            scale=self.scale,
+            window_size=self.window_size,
+            stride=self.stride,
+            dilation=self.dilation,
+            is_causal=self.is_causal,
+        )
+
+        torch.testing.assert_close(output.to(torch.float32), self.output_ref, atol=atol_fwd, rtol=rtol_fwd)
+
+        # Backward pass
+        if test_backward:
+            assert atol_bwd is not None
+            assert rtol_bwd is not None
+            atol_dq, atol_dk, atol_dv = atol_bwd
+
+            d_output = self.d_output.clone().detach().to(dtype)
+            output.backward(d_output)
+
+            dq = q.grad.detach().to(torch.float32)
+            dk = k.grad.detach().to(torch.float32)
+            dv = v.grad.detach().to(torch.float32)
+
+            torch.testing.assert_close(dq, self.dq_ref, atol=atol_dq, rtol=rtol_bwd)
+            torch.testing.assert_close(dk, self.dk_ref, atol=atol_dk, rtol=rtol_bwd)
+            torch.testing.assert_close(dv, self.dv_ref, atol=atol_dv, rtol=rtol_bwd)
+
+
+def idx2crd(index, shape) -> tuple:
+    rank = len(shape)
+    coord = []
+    residual = index
+    for i in range(rank - 1, -1, -1):
+        coord.append(residual % shape[i])
+        residual = residual // shape[i]
+
+    # assert residual == 0
+    return tuple(coord[::-1])
+
+
+def multi_dim_mask(
+    q_idx: int,
+    kv_idx: int,
+    token_layout_shape: tuple,
+    window_size: tuple,
+    stride: tuple,
+    dilation: tuple,
+    is_causal: tuple,
+) -> bool:
+    assert len(token_layout_shape) == len(window_size) == len(stride) == len(dilation) == len(is_causal)
+
+    # Reconstruct global Q and KV coordinates
+    q_crd = idx2crd(q_idx, token_layout_shape)
+    kv_crd = idx2crd(kv_idx, token_layout_shape)
+
+    masks = []
+    for q, kv, x, w, s, d, c in zip(q_crd, kv_crd, token_layout_shape, window_size, stride, dilation, is_causal):
+        # Coordinates within dilation group
+        q_crd_di = q // d
+        kv_crd_di = kv // d
+
+        # Dilation group coordinates
+        q_dilation_group_crd = q % d
+        kv_dilation_group_crd = kv % d
+
+        # Fixup input shape according to dilation group
+        dilation_group_padding = 1 - ((q_dilation_group_crd + (d - (x % d))) // d)
+        qkv_shape_corrected = (x // d) + dilation_group_padding
+
+        if c:
+            # Leader is the last (right-most) query in the stride group.
+            stride_group_leader = min(
+                (q_crd_di // s) * s + s - 1,
+                qkv_shape_corrected - 1,
+            )
+
+            if not (
+                (q_crd_di - kv_crd_di >= 0)  # window still ends at query index
+                and (stride_group_leader - kv_crd_di < w)
+                and (q_dilation_group_crd == kv_dilation_group_crd)
+            ):
+                return False
+
+        else:
+            # Window size left and right (non-causal only)
+            window_size_left = w // 2
+            window_size_right = w // 2 + (w % 2 - 1)
+
+            # Leader is the center-most query in the stride group.
+            # If stride is even, choose the right hand side center query.
+            stride_group_leader = min(
+                (q_crd_di // s) * s + (s // 2),
+                qkv_shape_corrected - 1,
+            )
+
+            window_center = min(max(stride_group_leader, window_size_left), qkv_shape_corrected - 1 - window_size_right)
+            w0 = window_center - kv_crd_di
+            w1 = kv_crd_di - window_center
+            if not (
+                (((0 <= w0) and (w0 <= window_size_left)) or ((0 <= w1) and (w1 <= window_size_right)))
+                and (q_dilation_group_crd == kv_dilation_group_crd)
+            ):
+                return False
+
+    return True
+
+
+def multi_dim_reference(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    window_size: tuple,
+    stride: tuple,
+    dilation: tuple,
+    is_causal: tuple,
+    scale: float,
+):
+    assert query.dim() in [4, 5, 6]
+    B, *token_layout_shape, H, D = query.shape
+    H_kv, _ = key.shape[-2:]
+    D_v = value.shape[-1]
+    seqlen = math.prod(token_layout_shape)
+
+    # cast from torch shape to tuple
+    token_layout_shape = tuple(x for x in token_layout_shape)
+
+    num_dims = len(token_layout_shape)
+
+    assert H % H_kv == 0
+    h_k = H // H_kv
+
+    query_t = query.flatten(1, num_dims).transpose(1, 2)
+    key_t = key.flatten(1, num_dims).transpose(1, 2)
+    value_t = value.flatten(1, num_dims).transpose(1, 2)
+
+    assert query_t.dim() == key_t.dim() == value_t.dim() == 4
+    assert query_t.shape[2] == key_t.shape[2] == value_t.shape[2] == seqlen
+
+    # Decomposed GQA/MQA implementation
+    if h_k > 1:
+        key_t = torch.repeat_interleave(key_t, repeats=h_k, dim=1, output_size=H)
+        value_t = torch.repeat_interleave(value_t, repeats=h_k, dim=1, output_size=H)
+
+    attn_scores = torch.matmul(query_t, key_t.transpose(-2, -1)) * scale
+
+    mask = torch.zeros((seqlen, seqlen), dtype=torch.bool)
+    is_valid = partial(
+        multi_dim_mask,
+        token_layout_shape=token_layout_shape,
+        window_size=window_size,
+        stride=stride,
+        dilation=dilation,
+        is_causal=is_causal,
+    )
+    for q, kv in product(range(mask.shape[0]), range(mask.shape[1])):
+        mask[q, kv] = not is_valid(q, kv)
+
+    mask_cu = mask.unsqueeze(0).unsqueeze(0).to(attn_scores.device)
+    attn_scores = attn_scores.masked_fill(mask_cu, float("-inf"))
+
+    attn_weights = attn_scores.softmax(dim=-1)
+
+    out = torch.matmul(attn_weights, value_t)
+
+    out = out.transpose(1, 2)
+
+    out = out.reshape(B, *token_layout_shape, H, D_v)
+
+    return out
+
+
+class MultiDimTest(unittest.TestCase):
+    def setUp(self):
+        _reset_everything()
+
+    def tearDown(self):
+        _reset_everything()
+
+    def _test_against_bmm_reference(
+        self,
+        batch: int,
+        heads: int,
+        token_layout_shape: tuple,
+        head_dim: int,
+        window_size: tuple,
+        stride: tuple,
+        dilation: tuple,
+        is_causal: tuple,
+        test_backward: bool,
+        backend: str,
+        scale: float | None = None,
+        heads_kv: int | None = None,
+        head_dim_v: int | None = None,
+    ):
+        reference_dtype = torch.float16
+        device = "cuda"
+        attention_fn = partial(multi_dimensional_attention, backend=backend)
+
+        log.debug(
+            "Running reference Multi-Dimensional Attention on: "
+            f"{batch=}, {heads=}, {heads_kv=}, {head_dim=}, {head_dim_v=}, "
+            f"{token_layout_shape=}, {window_size=}, {stride=}, {dilation=}, {is_causal=}."
+        )
+        tester = MultiDimTester(
+            reference_fn=multi_dim_reference,
+            batch=batch,
+            heads=heads,
+            heads_kv=heads_kv,
+            token_layout_shape=token_layout_shape,
+            head_dim=head_dim,
+            head_dim_v=head_dim_v,
+            window_size=window_size,
+            stride=stride,
+            dilation=dilation,
+            is_causal=is_causal,
+            dtype=reference_dtype,
+            test_backward=test_backward,
+            scale=scale,
+            device=device,
+        )
+
+        ALLOWED_DTYPES = [
+            # dtype, atol_out, (atol_dq, atol_dk, atol_dv), rtol_fwd, rtol_bwd
+            (torch.float16, 1e-2, (4e-2, 4e-2, 4e-2), 0, 0),
+            (torch.bfloat16, 1e-1, (2e-1, 2e-1, 2e-1), 0, 0),
+        ]
+        if backend == "natten" and is_blackwell_dc():
+            ALLOWED_DTYPES += [
+                (torch.float8_e4m3fn, 4e-1, None, 1e-1, 0),
+                (torch.float8_e5m2, 8e-1, None, 5e-1, 0),
+            ]
+
+        for dtype, atol_fwd, atol_bwd, rtol_fwd, rtol_bwd in ALLOWED_DTYPES:
+            test_backward_ = test_backward and not is_fp8(dtype)
+            log.debug(
+                f"Testing Multi-Dimensional Attention ({backend}): {batch=}, {heads=}, {heads_kv=}, {head_dim=}, {head_dim_v=}, "
+                f"{token_layout_shape=}, {window_size=}, {stride=}, {dilation=}, "
+                f"{is_causal=}, {dtype=}, {test_backward_=}."
+            )
+            tester.test(
+                target_fn=attention_fn,
+                dtype=dtype,
+                atol_fwd=atol_fwd,
+                atol_bwd=atol_bwd,
+                rtol_fwd=rtol_fwd,
+                rtol_bwd=rtol_bwd,
+                test_backward=test_backward_,
+            )
+
+    def _test_randsweep(self, num_dims: int, backend: str, max_tests: int = 1000, max_seqlen: int = 2**17):
+        random.seed(42)
+
+        for i in range(max_tests):
+            batch = random.choice(range(1, 2))
+
+            supports_mla = False
+            supports_gqa_mqa = False
+            if backend == "natten":
+                head_dim_choices = [32, 64, 128]
+                heads_choices = range(1, 4 + 1)
+                # GQA/MQA is not supported in FNA ops yet
+                supports_gqa_mqa = False
+
+                # Enable MLA when supported in hopper or blackwell
+                head_dim = random.choice(head_dim_choices)
+                head_dim_v = None
+                # head_dim_v = random.choice(head_dim_choices)
+
+            else:
+                raise NotImplementedError()
+
+            heads = random.choice(heads_choices)
+            heads_kv = (
+                heads
+                if not supports_gqa_mqa
+                else random.choice([1] + [i for i in range(1, heads + 1) if heads % i == 0])
+            )
+            assert heads >= heads_kv and heads % heads_kv == 0
+
+            token_layout_shape = []
+            for j in range(num_dims):
+                max_size = (
+                    min(max_seqlen, 16384)
+                    if j == 0
+                    else min(16384, max(10, max_seqlen - math.prod(token_layout_shape)))
+                )
+                token_layout_shape.append(random.choice(range(4, max_size)))
+
+            while math.prod(token_layout_shape) > max_seqlen:
+                dim_to_cut = random.choice(range(num_dims))
+                token_layout_shape[dim_to_cut] = max(4, int(token_layout_shape[dim_to_cut] * 0.1))
+
+            token_layout_shape = tuple(token_layout_shape)
+            window_size = tuple(random.choice(range(2, x + 1)) for x in token_layout_shape)
+            stride = tuple(random.choice(range(1, k + 1)) for k in window_size)
+            dilation = tuple(random.choice(range(1, x // k + 1)) for x, k in zip(token_layout_shape, window_size))
+            is_causal = tuple(random.choice([False, True]) for _ in range(num_dims))
+
+            self._test_against_bmm_reference(
+                batch=batch,
+                heads=heads,
+                heads_kv=heads_kv,
+                head_dim=head_dim,
+                head_dim_v=head_dim_v,
+                token_layout_shape=token_layout_shape,
+                window_size=window_size,
+                stride=stride,
+                dilation=dilation,
+                is_causal=is_causal,
+                backend=backend,
+                test_backward=True,
+            )
+
+    @pytest.mark.L1
+    @skip_if_natten_not_supported()
+    def test_natten_fast(self):
+        random.seed(83)
+        torch.manual_seed(83)
+        self._test_randsweep(num_dims=1, backend="natten", max_tests=10, max_seqlen=2**10)
+        self._test_randsweep(num_dims=2, backend="natten", max_tests=10, max_seqlen=2**10)
+        self._test_randsweep(num_dims=3, backend="natten", max_tests=10, max_seqlen=2**10)
+
+    @pytest.mark.L1
+    @pytest.mark.skip("Extended rand sweep is disabled until we have a faster reference for multi-dim")
+    @skip_if_natten_not_supported()
+    def test_natten_randsweep(self):
+        random.seed(84)
+        torch.manual_seed(84)
+        self._test_randsweep(num_dims=1, backend="natten", max_tests=RAND_SWEEP_TESTS // 3, max_seqlen=2**11)
+        self._test_randsweep(num_dims=2, backend="natten", max_tests=RAND_SWEEP_TESTS // 3, max_seqlen=2**11)
+        self._test_randsweep(num_dims=3, backend="natten", max_tests=RAND_SWEEP_TESTS // 3, max_seqlen=2**11)
+
+
+if __name__ == "__main__":
+    random.seed(42)
+    torch.manual_seed(42)
+    unittest.main()

REGEN-main/cosmos_policy/_src/imaginaire/attention/tests/sdpa_test.py

@@ -0,0 +1,1015 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+SDPA unit tests.
+"""
+
+import random
+import unittest
+from functools import partial
+from typing import Callable
+
+import pytest
+import torch
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention import attention as i4_attention
+from cosmos_policy._src.imaginaire.attention.cudnn import CUDNN_DISALLOWED, CUDNN_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.flash2 import FLASH2_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.flash3 import FLASH3_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.natten import NATTEN_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.utils import is_blackwell_dc, is_fp8, is_hopper
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+RAND_SWEEP_TESTS = 1000
+
+skip_if_cudnn_not_supported = partial(
+    pytest.mark.skipif,
+    CUDNN_DISALLOWED or not CUDNN_SUPPORTED,
+    reason="cuDNN is disabled, not available, or too old in this environment.",
+)
+
+skip_if_natten_not_supported = partial(
+    pytest.mark.skipif,
+    not NATTEN_SUPPORTED,
+    reason="NATTEN is disabled, not available, or too old in this environment.",
+)
+
+skip_if_flash2_not_supported = partial(
+    pytest.mark.skipif,
+    not FLASH2_SUPPORTED,
+    reason="Flash2 is disabled, not available, or too old in this environment.",
+)
+
+skip_if_flash3_not_supported = partial(
+    pytest.mark.skipif,
+    not FLASH3_SUPPORTED,
+    reason="Flash3 is disabled, not available, or too old in this environment.",
+)
+
+# Tests are only enabled on Hopper and Blackwell DC-class for now.
+# Will extend to other arches as we integrate more backends.
+skip_if_not_supported = partial(
+    pytest.mark.skipif,
+    not is_blackwell_dc() and not is_hopper(),
+    reason="SDPA tests are only allowed for Hopper and Blackwell DC-class GPUs for now.",
+)
+
+skip_if_not_blackwell = partial(
+    pytest.mark.skipif, not is_blackwell_dc(), reason="This test is only allowed for Blackwell DC-class GPUs."
+)
+
+skip_if_not_hopper = partial(pytest.mark.skipif, not is_hopper(), reason="This test is only allowed for Hopper GPUs.")
+
+
+def _reset_everything():
+    torch.manual_seed(42)
+    torch.cuda.empty_cache()
+
+
+class SdpaTester:
+    def __init__(
+        self,
+        reference_fn: Callable,
+        batch: int,
+        heads: int,
+        seqlen_q: int,
+        seqlen_kv: int,
+        head_dim: int,
+        test_backward: bool = True,
+        scale: float | None = None,
+        is_causal: bool = False,
+        causal_type: CausalType | None = None,
+        dtype: torch.dtype = torch.float32,
+        device: torch.device = "cuda",
+        heads_kv: int | None = None,
+        head_dim_v: int | None = None,
+    ):
+        self.batch = batch
+        self.heads = heads
+        self.heads_kv = heads_kv or heads
+        self.seqlen_q = seqlen_q
+        self.seqlen_kv = seqlen_kv
+        self.head_dim = head_dim
+        self.head_dim_v = head_dim_v or head_dim
+        self.test_backward = test_backward
+        self.scale = scale if scale is not None else head_dim**-0.5
+        self.is_causal = is_causal
+        self.causal_type = causal_type
+        self.dtype = dtype
+        self.device = device
+
+        # Initialize input tensors
+        self.q = torch.randn(
+            self.batch,
+            self.seqlen_q,
+            self.heads,
+            self.head_dim,
+            dtype=dtype,
+            device=device,
+            requires_grad=test_backward,
+        )
+        self.k = torch.randn(
+            self.batch,
+            self.seqlen_kv,
+            self.heads_kv,
+            self.head_dim,
+            dtype=dtype,
+            device=device,
+            requires_grad=test_backward,
+        )
+        self.v = torch.randn(
+            self.batch,
+            self.seqlen_kv,
+            self.heads_kv,
+            self.head_dim_v,
+            dtype=dtype,
+            device=device,
+            requires_grad=test_backward,
+        )
+        self.d_output = (
+            torch.randn(self.batch, self.seqlen_q, self.heads, self.head_dim_v, dtype=dtype, device=device)
+            if test_backward
+            else None
+        )
+
+        # Run reference implementation
+        q_ref = self.q.clone().detach().requires_grad_(self.test_backward)
+        k_ref = self.k.clone().detach().requires_grad_(self.test_backward)
+        v_ref = self.v.clone().detach().requires_grad_(self.test_backward)
+
+        output_ref = reference_fn(
+            query=q_ref,
+            key=k_ref,
+            value=v_ref,
+            scale=self.scale,
+            is_causal=self.is_causal,
+            causal_type=self.causal_type,
+        )
+
+        self.output_ref = output_ref.detach().to(torch.float32)
+
+        # Reference backward pass
+        if self.test_backward:
+            d_output = self.d_output.clone().detach()
+            output_ref.backward(d_output)
+            self.dq_ref = q_ref.grad.detach().to(torch.float32)
+            self.dk_ref = k_ref.grad.detach().to(torch.float32)
+            self.dv_ref = v_ref.grad.detach().to(torch.float32)
+
+    def test(
+        self,
+        target_fn: Callable,
+        dtype: torch.dtype,
+        atol_fwd: float,
+        atol_bwd: tuple[float, float, float] | None = None,
+        rtol_fwd: float = 0.0,
+        rtol_bwd: float = 0.0,
+        test_backward: bool | None = None,
+    ):
+        test_backward = self.test_backward if test_backward is None else test_backward
+
+        q = self.q.clone().detach().to(dtype).requires_grad_(test_backward)
+        k = self.k.clone().detach().to(dtype).requires_grad_(test_backward)
+        v = self.v.clone().detach().to(dtype).requires_grad_(test_backward)
+
+        output = target_fn(
+            query=q, key=k, value=v, scale=self.scale, is_causal=self.is_causal, causal_type=self.causal_type
+        )
+
+        torch.testing.assert_close(output.to(torch.float32), self.output_ref, atol=atol_fwd, rtol=rtol_fwd)
+
+        # Backward pass
+        if test_backward:
+            assert atol_bwd is not None
+            assert rtol_bwd is not None
+            atol_dq, atol_dk, atol_dv = atol_bwd
+
+            d_output = self.d_output.clone().detach().to(dtype)
+            output.backward(d_output)
+
+            dq = q.grad.detach().to(torch.float32)
+            dk = k.grad.detach().to(torch.float32)
+            dv = v.grad.detach().to(torch.float32)
+
+            torch.testing.assert_close(dq, self.dq_ref, atol=atol_dq, rtol=rtol_bwd)
+            torch.testing.assert_close(dk, self.dk_ref, atol=atol_dk, rtol=rtol_bwd)
+            torch.testing.assert_close(dv, self.dv_ref, atol=atol_dv, rtol=rtol_bwd)
+
+
+def torch_sdpa_reference(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    scale: float,
+    is_causal: bool,
+    causal_type: CausalType,
+):
+    heads = query.shape[2]
+    heads_kv = key.shape[2]
+    assert heads % heads_kv == 0
+    h_k = heads // heads_kv
+
+    assert not is_causal or causal_type == CausalType.TopLeft, "Torch SDPA only supports top-left causal mask."
+
+    # Torch requires heads-first layout
+    query = query.permute(0, 2, 1, 3).contiguous()
+    key = key.permute(0, 2, 1, 3).contiguous()
+    value = value.permute(0, 2, 1, 3).contiguous()
+
+    k_final, v_final = key, value
+    # Decomposed GQA/MQA implementation for torch SDPA via explicit repeats
+    if h_k > 1:
+        k_final = torch.repeat_interleave(key, repeats=h_k, dim=1, output_size=heads)
+        v_final = torch.repeat_interleave(value, repeats=h_k, dim=1, output_size=heads)
+
+        assert k_final.shape[:2] == query.shape[:2]
+        assert v_final.shape[:2] == query.shape[:2]
+        assert k_final.shape[-1] == query.shape[-1]
+        assert v_final.shape[-1] == query.shape[-1]
+
+    with torch.nn.attention.sdpa_kernel(backends=[torch.nn.attention.SDPBackend.EFFICIENT_ATTENTION]):
+        out = torch.nn.functional.scaled_dot_product_attention(
+            query, k_final, v_final, is_causal=is_causal, scale=scale
+        )
+
+    out = out.permute(0, 2, 1, 3).contiguous()
+    return out
+
+
+# NOTE: Use ONLY when seqlen_{q,kv} are small!
+# Supports MLA and bottom-right causal mask, unlike SDPA
+def bmm_sdpa_reference(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    scale: float,
+    is_causal: bool,
+    causal_type: CausalType,
+    MAX_QK: int = 16384**2,
+):
+    B, S_q, H, D = query.shape
+    _, S_kv, H_kv, _ = key.shape
+
+    assert H % H_kv == 0
+    h_k = H // H_kv
+
+    if S_q * S_kv > MAX_QK:
+        raise ValueError(f"Query-key matmul too large: {S_q}*{S_kv} > MAX_QK={MAX_QK}")
+
+    query_t = query.transpose(1, 2)
+    key_t = key.transpose(1, 2)
+    value_t = value.transpose(1, 2)
+
+    # Decomposed GQA/MQA implementation
+    if h_k > 1:
+        key_t = torch.repeat_interleave(key_t, repeats=h_k, dim=1, output_size=H)
+        value_t = torch.repeat_interleave(value_t, repeats=h_k, dim=1, output_size=H)
+
+    attn_scores = torch.matmul(query_t, key_t.transpose(-2, -1)) * scale
+
+    if is_causal:
+        if causal_type == CausalType.TopLeft:
+            diagonal_offset = 1
+        elif causal_type == CausalType.BottomRight:
+            diagonal_offset = S_kv - S_q + 1
+        else:
+            raise NotImplementedError()
+        mask = torch.triu(torch.ones(S_q, S_kv, device=query.device, dtype=torch.bool), diagonal=diagonal_offset)
+        attn_scores = attn_scores.masked_fill(mask, float("-inf"))
+
+    attn_weights = attn_scores.softmax(dim=-1)
+
+    # We can have entirely masked rows (queries) with this mask
+    if causal_type == CausalType.BottomRight:
+        attn_weights = torch.nan_to_num(attn_weights, nan=0.0)
+
+    out = torch.matmul(attn_weights, value_t)
+
+    out = out.transpose(1, 2)
+
+    return out
+
+
+class SdpaTest(unittest.TestCase):
+    def setUp(self):
+        _reset_everything()
+
+    def tearDown(self):
+        _reset_everything()
+
+    def _test_against_torch_sdpa(
+        self,
+        batch: int,
+        heads: int,
+        head_dim: int,
+        seqlen_q: int,
+        seqlen_kv: int,
+        is_causal: bool,
+        causal_type: CausalType,
+        test_backward: bool,
+        backend: str,
+        scale: float | None = None,
+        heads_kv: int | None = None,
+        head_dim_v: int | None = None,
+    ):
+        reference_dtype = torch.float16
+        device = "cuda"
+        attention_fn = partial(i4_attention, backend=backend)
+
+        reference_fn = torch_sdpa_reference
+        if (is_causal and causal_type == CausalType.BottomRight) or (head_dim_v is not None and head_dim_v != head_dim):
+            reference_fn = bmm_sdpa_reference
+
+        tester = SdpaTester(
+            reference_fn=reference_fn,
+            batch=batch,
+            heads=heads,
+            heads_kv=heads_kv,
+            head_dim=head_dim,
+            head_dim_v=head_dim_v,
+            seqlen_q=seqlen_q,
+            seqlen_kv=seqlen_kv,
+            dtype=reference_dtype,
+            test_backward=test_backward,
+            scale=scale,
+            is_causal=is_causal,
+            causal_type=causal_type,
+            device=device,
+        )
+
+        ALLOWED_DTYPES = [
+            # dtype, atol_out, (atol_dq, atol_dk, atol_dv), rtol_fwd, rtol_bwd
+            (torch.float16, 1e-2, (4e-2, 4e-2, 4e-2), 0, 0),
+            (torch.bfloat16, 1e-1, (2e-1, 2e-1, 2e-1), 0, 0),
+        ]
+        if backend == "natten" and is_blackwell_dc():
+            ALLOWED_DTYPES += [
+                (torch.float8_e4m3fn, 4e-1, None, 1e-1, 0),
+                (torch.float8_e5m2, 8e-1, None, 5e-1, 0),
+            ]
+
+        for dtype, atol_fwd, atol_bwd, rtol_fwd, rtol_bwd in ALLOWED_DTYPES:
+            test_backward_ = test_backward and not is_fp8(dtype)
+            log.debug(
+                f"Testing SDPA ({backend}) vs torch SDPA: {batch=}, {heads=}, {heads_kv=}, {head_dim=}, {head_dim_v=}, "
+                f"{seqlen_q=}, {seqlen_kv=}, {is_causal=}, {causal_type=}, {dtype=}, {test_backward_=}"
+            )
+            tester.test(
+                target_fn=attention_fn,
+                dtype=dtype,
+                atol_fwd=atol_fwd,
+                atol_bwd=atol_bwd,
+                rtol_fwd=rtol_fwd,
+                rtol_bwd=rtol_bwd,
+                test_backward=test_backward_,
+            )
+
+    def _test_backend_against_torch_sdpa(
+        self,
+        batch: int,
+        heads: int,
+        head_dim: int,
+        seqlen_q: int,
+        seqlen_kv: int,
+        is_causal: bool,
+        backend: str,
+        scale: float | None = None,
+        heads_kv: int | None = None,
+        head_dim_v: int | None = None,
+    ):
+        assert backend in ["natten", "flash2", "flash3", "cudnn"]
+        self._test_against_torch_sdpa(
+            batch=batch,
+            heads=heads,
+            heads_kv=heads_kv,
+            head_dim=head_dim,
+            head_dim_v=head_dim_v,
+            seqlen_q=seqlen_q,
+            seqlen_kv=seqlen_kv,
+            is_causal=is_causal,
+            causal_type=CausalType.TopLeft if backend not in ["flash2", "flash3"] else CausalType.BottomRight,
+            scale=scale,
+            test_backward=backend != "cudnn",
+            backend=backend,
+        )
+
+    def _test_randsweep_against_torch_sdpa(self, backend: str, max_tests: int = 1000):
+        random.seed(42)
+
+        max_qk = 2**21
+        for i in range(max_tests):
+            batch = random.choice(range(1, 4))
+
+            supports_mla = False
+            supports_gqa_mqa = False
+            if backend == "natten":
+                head_dim_choices = [32, 64, 128]
+                heads_choices = range(1, 8 + 1)
+                # GQA/MQA is only supported in NATTEN's Blackwell FMHA backend for now
+                supports_gqa_mqa = is_blackwell_dc()
+
+                # Enable MLA when supported in hopper or blackwell
+                head_dim = random.choice(head_dim_choices)
+                head_dim_v = None
+                # head_dim_v = random.choice(head_dim_choices)
+
+            elif backend in ["flash2", "flash3"]:
+                head_dim_choices = range(16, 256 + 1, 8)
+                heads_choices = range(1, 8 + 1)
+                supports_gqa_mqa = True
+
+                # NOTE: Flash 3 MLA fails a static check in bwd, seems like an FA bug
+                ## Flash 3 supports MLA, but with some extra constraints
+                # if backend == "flash3" and random.choice([True, False]):
+                #    # Either head_dim_qk <= 64 and head_dim_v <= 512, or
+                #    # 128 <= head_dim_qk <= 192 and 96 <= head_dim_v <= 128
+                #    if random.choice([True, False]):
+                #        head_dim = random.choice(range(16, 64 + 1, 8))
+                #        head_dim_v = random.choice(head_dim_choices)
+                #    else:
+                #        head_dim = random.choice(range(128, 192 + 1, 8))
+                #        head_dim_v = random.choice(range(96, 128 + 1, 8))
+
+                # else:
+                head_dim = random.choice(head_dim_choices)
+                head_dim_v = None
+
+            elif backend == "cudnn":
+                head_dim_choices = [32, 64, 128]
+                heads_choices = range(1, 4)
+
+                # Enable MLA when verified
+                head_dim = random.choice(head_dim_choices)
+                head_dim_v = None
+                # head_dim_v = random.choice(head_dim_choices)
+
+            else:
+                raise NotImplementedError()
+
+            heads = random.choice(heads_choices)
+            heads_kv = (
+                heads
+                if not supports_gqa_mqa
+                else random.choice([1] + [i for i in range(1, heads + 1) if heads % i == 0])
+            )
+            assert heads >= heads_kv and heads % heads_kv == 0
+
+            seqlen_q = random.choice(range(16, 2**14, 1))
+            seqlen_kv = random.choice(range(16, 2**14, 1))
+
+            is_causal = random.choice([True, False])
+
+            while seqlen_q * seqlen_kv > max_qk:
+                cut_kv = random.choice([True, False])
+                if cut_kv:
+                    seqlen_kv = int(seqlen_kv * 0.75)
+                else:
+                    seqlen_q = int(seqlen_q * 0.75)
+
+            self._test_backend_against_torch_sdpa(
+                batch=batch,
+                heads=heads,
+                heads_kv=heads_kv,
+                head_dim=head_dim,
+                head_dim_v=head_dim_v,
+                seqlen_q=seqlen_q,
+                seqlen_kv=seqlen_kv,
+                is_causal=is_causal,
+                backend=backend,
+            )
+
+    @pytest.mark.L1
+    @skip_if_cudnn_not_supported()
+    @skip_if_not_blackwell()
+    def test_cudnn_fast(self):
+        problem_sizes = [
+            #### fp16 NaN??!!
+            #### batch=1, heads=13, head_dim=128, seqlen_q=7688, seqlen_kv=256, is_causal=False, dtype=torch.float16
+            (1, 8, 128, 16384, 16384),
+            (1, 13, 128, 7688, 256),
+            #### illegal mem access -- seems intermittent
+            ## batch=6, heads=2, head_dim=128, seqlen_q=12244, seqlen_kv=123, is_causal=False, dtype=torch.float16
+            (6, 2, 128, 12244, 123),
+            #####
+            (2, 1, 128, 2048, 2048),
+            (2, 1, 64, 2048, 2048),
+            (4, 1, 64, 2048, 2048),
+            ### Failing FP16 case:
+            ### batch=2, heads=1, head_dim=64, seqlen_q=1411, seqlen_kv=1375, is_causal=False, dtype=torch.float16
+            (1, 1, 64, 1411, 1375),
+            (2, 1, 64, 1536, 1280),
+            (2, 1, 64, 1536, 1536),
+            (2, 1, 64, 1536, 1376),
+            (2, 1, 64, 1416, 1376),
+            (2, 1, 64, 1411, 1375),
+            ### NaN case
+            ### batch=3, heads=3, head_dim=64, seqlen_q=9197, seqlen_kv=166,
+            (1, 1, 64, 10240, 512),
+            (2, 1, 64, 10240, 512),
+            (4, 1, 64, 10240, 512),
+            (8, 1, 64, 10240, 512),
+            #####
+            (3, 1, 64, 10240, 512),
+            (4, 1, 64, 10240, 512),
+            (5, 1, 64, 10240, 512),
+            (6, 1, 64, 10240, 512),
+            (7, 1, 64, 10240, 512),
+            (8, 1, 64, 10240, 512),
+            (3, 3, 64, 10240, 512),
+            (3, 3, 64, 9216, 512),
+            (3, 3, 64, 9200, 512),
+            (3, 3, 64, 9200, 512),
+            (3, 3, 64, 9200, 512),
+            (3, 3, 64, 9200, 512),
+            (3, 3, 64, 9198, 512),
+            (3, 3, 64, 9197, 512),
+            #
+            (3, 1, 64, 10240, 256),
+            (4, 1, 64, 10240, 256),
+            (5, 1, 64, 10240, 256),
+            (6, 1, 64, 10240, 256),
+            (7, 1, 64, 10240, 256),
+            (8, 1, 64, 10240, 256),
+            (3, 3, 64, 10240, 256),
+            (3, 3, 64, 9216, 256),
+            (3, 3, 64, 9200, 256),
+            (3, 3, 64, 9200, 192),
+            (3, 3, 64, 9200, 168),
+            (3, 3, 64, 9200, 166),
+            (3, 3, 64, 9198, 166),
+            (3, 3, 64, 9197, 166),
+            # Passing:
+            (4, 1, 64, 10240, 10240),
+            (4, 1, 64, 10240, 1024),
+            (1, 1, 64, 9197, 166),
+            (3, 3, 64, 2560, 256),
+            #
+            (1, 1, 128, 128, 128),
+            (2, 1, 128, 128, 128),
+            (1, 2, 128, 128, 128),
+            (2, 2, 128, 128, 128),
+            (2, 2, 64, 128, 128),
+            (1, 1, 32, 32, 32),
+            (1, 1, 32, 128, 128),
+            (1, 1, 32, 128, 128),
+            (1, 1, 128, 128, 64),
+            (1, 1, 32, 128, 258),
+            (1, 2, 64, 128, 15),
+            (1, 1, 32, 8, 17),
+            (1, 1, 64, 17, 49),
+            (2, 4, 32, 128, 237),
+            (4, 3, 64, 256, 33),
+            (1, 1, 128, 128, 75),
+            (1, 1, 32, 125, 444),
+            (1, 2, 64, 125, 231),
+            (1, 1, 128, 256, 10240),
+            (1, 1, 32, 128, 4096),
+            (1, 1, 128, 3584, 381),
+            (1, 1, 128, 12072, 1680),
+        ]
+        for (
+            batch,
+            heads,
+            head_dim,
+            seqlen_q,
+            seqlen_kv,
+        ) in problem_sizes:
+            for is_causal in [False, True]:
+                self._test_backend_against_torch_sdpa(
+                    batch=batch,
+                    heads=heads,
+                    head_dim=head_dim,
+                    seqlen_q=seqlen_q,
+                    seqlen_kv=seqlen_kv,
+                    is_causal=is_causal,
+                    backend="cudnn",
+                )
+
+    @pytest.mark.L1
+    @skip_if_cudnn_not_supported()
+    @skip_if_not_blackwell()
+    def test_cudnn_randsweep(self):
+        self._test_randsweep_against_torch_sdpa(backend="cudnn", max_tests=RAND_SWEEP_TESTS)
+
+    @pytest.mark.L1
+    @skip_if_natten_not_supported()
+    @skip_if_not_blackwell()
+    def test_natten_blackwell_fast(self):
+        problem_sizes = [
+            (1, 8, 8, 128, 16384, 16384),
+            (1, 8, 4, 128, 16384, 16384),
+            (1, 8, 2, 128, 16384, 16384),
+            (1, 8, 1, 128, 16384, 16384),
+            (1, 12, 12, 128, 7688, 256),
+            (1, 12, 6, 128, 7688, 256),
+            (1, 12, 4, 128, 7688, 256),
+            (1, 12, 3, 128, 7688, 256),
+            (1, 12, 2, 128, 7688, 256),
+            (1, 12, 1, 128, 7688, 256),
+            (6, 2, 2, 128, 12244, 123),
+            (6, 2, 1, 128, 12244, 123),
+            (2, 1, 1, 128, 2048, 2048),
+            (2, 1, 1, 64, 2048, 2048),
+            (4, 1, 1, 64, 2048, 2048),
+            (1, 1, 1, 64, 1411, 1375),
+            (2, 1, 1, 64, 1536, 1280),
+            (2, 1, 1, 64, 1536, 1536),
+            (2, 1, 1, 64, 1536, 1376),
+            (2, 1, 1, 64, 1416, 1376),
+            (2, 1, 1, 64, 1411, 1375),
+            (1, 1, 1, 64, 10240, 512),
+            (2, 1, 1, 64, 10240, 512),
+            (4, 1, 1, 64, 10240, 512),
+            (8, 1, 1, 64, 10240, 512),
+            (3, 1, 1, 64, 10240, 512),
+            (4, 1, 1, 64, 10240, 512),
+            (5, 1, 1, 64, 10240, 512),
+            (6, 1, 1, 64, 10240, 512),
+            (7, 1, 1, 64, 10240, 512),
+            (8, 1, 1, 64, 10240, 512),
+            (3, 3, 3, 64, 9197, 512),
+            (3, 3, 1, 64, 9197, 512),
+            (7, 1, 1, 64, 10240, 256),
+            (3, 3, 3, 64, 10240, 256),
+            (3, 3, 3, 64, 9216, 256),
+            (3, 3, 3, 64, 9200, 256),
+            (3, 3, 3, 64, 9200, 192),
+            (3, 3, 3, 64, 9200, 168),
+            (3, 3, 3, 64, 9200, 166),
+            (3, 3, 3, 64, 9198, 166),
+            (3, 3, 3, 64, 9197, 166),
+            (4, 1, 1, 64, 10240, 10240),
+            (4, 1, 1, 64, 10240, 1024),
+            (1, 1, 1, 64, 9197, 166),
+            (3, 3, 3, 64, 2560, 256),
+            (1, 1, 1, 128, 128, 128),
+            (2, 1, 1, 128, 128, 128),
+            (1, 2, 2, 128, 128, 128),
+            (2, 2, 2, 128, 128, 128),
+            (2, 2, 2, 64, 128, 128),
+            (1, 1, 1, 32, 32, 32),
+            (1, 1, 1, 32, 128, 128),
+            (1, 1, 1, 32, 128, 128),
+            (1, 1, 1, 128, 128, 64),
+            (1, 1, 1, 32, 128, 258),
+            (1, 2, 2, 64, 128, 15),
+            (1, 1, 1, 32, 8, 17),
+            (1, 1, 1, 64, 17, 49),
+            (2, 4, 4, 32, 128, 237),
+            (2, 4, 2, 32, 128, 237),
+            (2, 4, 1, 32, 128, 237),
+            (4, 3, 3, 64, 256, 33),
+            (4, 3, 1, 64, 256, 33),
+            (1, 1, 1, 128, 128, 75),
+            (1, 1, 1, 32, 125, 444),
+            (1, 2, 2, 64, 125, 231),
+            (1, 2, 1, 64, 125, 231),
+            (1, 1, 1, 128, 256, 10240),
+            (1, 1, 1, 32, 128, 4096),
+            (1, 1, 1, 128, 3584, 381),
+            (1, 1, 1, 128, 12072, 1680),
+        ]
+        for (
+            batch,
+            heads,
+            heads_kv,
+            head_dim,
+            seqlen_q,
+            seqlen_kv,
+        ) in problem_sizes:
+            for is_causal in [False, True]:
+                self._test_backend_against_torch_sdpa(
+                    batch=batch,
+                    heads=heads,
+                    heads_kv=heads_kv,
+                    head_dim=head_dim,
+                    seqlen_q=seqlen_q,
+                    seqlen_kv=seqlen_kv,
+                    is_causal=is_causal,
+                    backend="natten",
+                )
+
+    @pytest.mark.L1
+    @skip_if_natten_not_supported()
+    @skip_if_not_hopper()
+    def test_natten_hopper_fast(self):
+        # No GQA/MQA
+        # No MLA (except when using Ampere kernels)
+        # No causal masking (except when using Ampere kernels)
+        problem_sizes = [
+            (1, 8, 8, 128, 16384, 16384),
+            (1, 12, 12, 128, 7688, 256),
+            (6, 2, 2, 128, 12244, 123),
+            (2, 1, 1, 128, 2048, 2048),
+            (2, 1, 1, 64, 2048, 2048),
+            (4, 1, 1, 64, 2048, 2048),
+            (1, 1, 1, 64, 1411, 1375),
+            (2, 1, 1, 64, 1536, 1280),
+            (2, 1, 1, 64, 1536, 1536),
+            (2, 1, 1, 64, 1536, 1376),
+            (2, 1, 1, 64, 1416, 1376),
+            (2, 1, 1, 64, 1411, 1375),
+            (1, 1, 1, 64, 10240, 512),
+            (2, 1, 1, 64, 10240, 512),
+            (4, 1, 1, 64, 10240, 512),
+            (8, 1, 1, 64, 10240, 512),
+            (3, 1, 1, 64, 10240, 512),
+            (4, 1, 1, 64, 10240, 512),
+            (5, 1, 1, 64, 10240, 512),
+            (6, 1, 1, 64, 10240, 512),
+            (7, 1, 1, 64, 10240, 512),
+            (8, 1, 1, 64, 10240, 512),
+            (3, 3, 3, 64, 9197, 512),
+            (7, 1, 1, 64, 10240, 256),
+            (3, 3, 3, 64, 10240, 256),
+            (3, 3, 3, 64, 9216, 256),
+            (3, 3, 3, 64, 9200, 256),
+            (3, 3, 3, 64, 9200, 192),
+            (3, 3, 3, 64, 9200, 168),
+            (3, 3, 3, 64, 9200, 166),
+            (3, 3, 3, 64, 9198, 166),
+            (3, 3, 3, 64, 9197, 166),
+            (4, 1, 1, 64, 10240, 10240),
+            (4, 1, 1, 64, 10240, 1024),
+            (1, 1, 1, 64, 9197, 166),
+            (3, 3, 3, 64, 2560, 256),
+            (1, 1, 1, 128, 128, 128),
+            (2, 1, 1, 128, 128, 128),
+            (1, 2, 2, 128, 128, 128),
+            (2, 2, 2, 128, 128, 128),
+            (2, 2, 2, 64, 128, 128),
+            (1, 1, 1, 32, 32, 32),
+            (1, 1, 1, 32, 128, 128),
+            (1, 1, 1, 32, 128, 128),
+            (1, 1, 1, 128, 128, 64),
+            (1, 1, 1, 32, 128, 258),
+            (1, 2, 2, 64, 128, 15),
+            (1, 1, 1, 32, 8, 17),
+            (1, 1, 1, 64, 17, 49),
+            (2, 4, 4, 32, 128, 237),
+            (4, 3, 3, 64, 256, 33),
+            (1, 1, 1, 128, 128, 75),
+            (1, 1, 1, 32, 125, 444),
+            (1, 2, 2, 64, 125, 231),
+            (1, 1, 1, 128, 256, 10240),
+            (1, 1, 1, 32, 128, 4096),
+            (1, 1, 1, 128, 3584, 381),
+            (1, 1, 1, 128, 12072, 1680),
+        ]
+        for (
+            batch,
+            heads,
+            heads_kv,
+            head_dim,
+            seqlen_q,
+            seqlen_kv,
+        ) in problem_sizes:
+            for is_causal in [False, True]:
+                self._test_backend_against_torch_sdpa(
+                    batch=batch,
+                    heads=heads,
+                    heads_kv=heads_kv,
+                    head_dim=head_dim,
+                    seqlen_q=seqlen_q,
+                    seqlen_kv=seqlen_kv,
+                    is_causal=is_causal,
+                    backend="natten",
+                )
+
+    @pytest.mark.L1
+    @skip_if_natten_not_supported()
+    @skip_if_not_supported()
+    def test_natten_randsweep(self):
+        self._test_randsweep_against_torch_sdpa(backend="natten", max_tests=RAND_SWEEP_TESTS)
+
+    @pytest.mark.L1
+    @skip_if_flash2_not_supported()
+    @skip_if_not_supported()
+    def test_flash2_fast(self):
+        problem_sizes = [
+            (1, 8, 8, 128, 16384, 16384),
+            (1, 8, 4, 128, 16384, 16384),
+            (1, 8, 2, 128, 16384, 16384),
+            (1, 8, 1, 128, 16384, 16384),
+            (1, 12, 12, 128, 7688, 256),
+            (1, 12, 6, 128, 7688, 256),
+            (1, 12, 4, 128, 7688, 256),
+            (1, 12, 3, 128, 7688, 256),
+            (1, 12, 2, 128, 7688, 256),
+            (1, 12, 1, 128, 7688, 256),
+            (6, 2, 2, 128, 12244, 123),
+            (6, 2, 1, 128, 12244, 123),
+            (2, 1, 1, 128, 2048, 2048),
+            (2, 1, 1, 64, 2048, 2048),
+            (4, 1, 1, 64, 2048, 2048),
+            (1, 1, 1, 64, 1411, 1375),
+            (2, 1, 1, 64, 1536, 1280),
+            (2, 1, 1, 64, 1536, 1536),
+            (2, 1, 1, 64, 1536, 1376),
+            (2, 1, 1, 64, 1416, 1376),
+            (2, 1, 1, 64, 1411, 1375),
+            (1, 1, 1, 64, 10240, 512),
+            (2, 1, 1, 64, 10240, 512),
+            (4, 1, 1, 64, 10240, 512),
+            (8, 1, 1, 64, 10240, 512),
+            (3, 1, 1, 64, 10240, 512),
+            (4, 1, 1, 64, 10240, 512),
+            (5, 1, 1, 64, 10240, 512),
+            (6, 1, 1, 64, 10240, 512),
+            (7, 1, 1, 64, 10240, 512),
+            (8, 1, 1, 64, 10240, 512),
+            (3, 3, 3, 64, 9197, 512),
+            (3, 3, 1, 64, 9197, 512),
+            (7, 1, 1, 64, 10240, 256),
+            (3, 3, 3, 64, 10240, 256),
+            (3, 3, 3, 64, 9216, 256),
+            (3, 3, 3, 64, 9200, 256),
+            (3, 3, 3, 64, 9200, 192),
+            (3, 3, 3, 64, 9200, 168),
+            (3, 3, 3, 64, 9200, 166),
+            (3, 3, 3, 64, 9198, 166),
+            (3, 3, 3, 64, 9197, 166),
+            (4, 1, 1, 64, 10240, 10240),
+            (4, 1, 1, 64, 10240, 1024),
+            (1, 1, 1, 64, 9197, 166),
+            (3, 3, 3, 64, 2560, 256),
+            (1, 1, 1, 128, 128, 128),
+            (2, 1, 1, 128, 128, 128),
+            (1, 2, 2, 128, 128, 128),
+            (2, 2, 2, 128, 128, 128),
+            (2, 2, 2, 64, 128, 128),
+            (1, 1, 1, 32, 32, 32),
+            (1, 1, 1, 32, 128, 128),
+            (1, 1, 1, 32, 128, 128),
+            (1, 1, 1, 128, 128, 64),
+            (1, 1, 1, 32, 128, 258),
+            (1, 2, 2, 64, 128, 15),
+            (1, 1, 1, 32, 8, 17),
+            (1, 1, 1, 64, 17, 49),
+            (2, 4, 4, 32, 128, 237),
+            (2, 4, 2, 32, 128, 237),
+            (2, 4, 1, 32, 128, 237),
+            (4, 3, 3, 64, 256, 33),
+            (4, 3, 1, 64, 256, 33),
+            (1, 1, 1, 128, 128, 75),
+            (1, 1, 1, 32, 125, 444),
+            (1, 2, 2, 64, 125, 231),
+            (1, 2, 1, 64, 125, 231),
+            (1, 1, 1, 128, 256, 10240),
+            (1, 1, 1, 32, 128, 4096),
+            (1, 1, 1, 128, 3584, 381),
+            (1, 1, 1, 128, 12072, 1680),
+        ]
+        for (
+            batch,
+            heads,
+            heads_kv,
+            head_dim,
+            seqlen_q,
+            seqlen_kv,
+        ) in problem_sizes:
+            for is_causal in [False, True]:
+                self._test_backend_against_torch_sdpa(
+                    batch=batch,
+                    heads=heads,
+                    heads_kv=heads_kv,
+                    head_dim=head_dim,
+                    seqlen_q=seqlen_q,
+                    seqlen_kv=seqlen_kv,
+                    is_causal=is_causal,
+                    backend="flash2",
+                )
+
+    @pytest.mark.L1
+    @skip_if_flash2_not_supported()
+    @skip_if_not_supported()
+    def test_flash2_randsweep(self):
+        self._test_randsweep_against_torch_sdpa(backend="flash2", max_tests=RAND_SWEEP_TESTS)
+
+    @pytest.mark.L1
+    @skip_if_flash3_not_supported()
+    @skip_if_not_supported()
+    def test_flash3_fast(self):
+        problem_sizes = [
+            (1, 8, 8, 128, 16384, 16384),
+            (1, 8, 4, 128, 16384, 16384),
+            (1, 8, 2, 128, 16384, 16384),
+            (1, 8, 1, 128, 16384, 16384),
+            (1, 12, 12, 128, 7688, 256),
+            (1, 12, 6, 128, 7688, 256),
+            (1, 12, 4, 128, 7688, 256),
+            (1, 12, 3, 128, 7688, 256),
+            (1, 12, 2, 128, 7688, 256),
+            (1, 12, 1, 128, 7688, 256),
+            (6, 2, 2, 128, 12244, 123),
+            (6, 2, 1, 128, 12244, 123),
+            (2, 1, 1, 128, 2048, 2048),
+            (2, 1, 1, 64, 2048, 2048),
+            (4, 1, 1, 64, 2048, 2048),
+            (1, 1, 1, 64, 1411, 1375),
+            (2, 1, 1, 64, 1536, 1280),
+            (2, 1, 1, 64, 1536, 1536),
+            (2, 1, 1, 64, 1536, 1376),
+            (2, 1, 1, 64, 1416, 1376),
+            (2, 1, 1, 64, 1411, 1375),
+            (1, 1, 1, 64, 10240, 512),
+            (2, 1, 1, 64, 10240, 512),
+            (4, 1, 1, 64, 10240, 512),
+            (8, 1, 1, 64, 10240, 512),
+            (3, 1, 1, 64, 10240, 512),
+            (4, 1, 1, 64, 10240, 512),
+            (5, 1, 1, 64, 10240, 512),
+            (6, 1, 1, 64, 10240, 512),
+            (7, 1, 1, 64, 10240, 512),
+            (8, 1, 1, 64, 10240, 512),
+            (3, 3, 3, 64, 9197, 512),
+            (3, 3, 1, 64, 9197, 512),
+            (7, 1, 1, 64, 10240, 256),
+            (3, 3, 3, 64, 10240, 256),
+            (3, 3, 3, 64, 9216, 256),
+            (3, 3, 3, 64, 9200, 256),
+            (3, 3, 3, 64, 9200, 192),
+            (3, 3, 3, 64, 9200, 168),
+            (3, 3, 3, 64, 9200, 166),
+            (3, 3, 3, 64, 9198, 166),
+            (3, 3, 3, 64, 9197, 166),
+            (4, 1, 1, 64, 10240, 10240),
+            (4, 1, 1, 64, 10240, 1024),
+            (1, 1, 1, 64, 9197, 166),
+            (3, 3, 3, 64, 2560, 256),
+            (1, 1, 1, 128, 128, 128),
+            (2, 1, 1, 128, 128, 128),
+            (1, 2, 2, 128, 128, 128),
+            (2, 2, 2, 128, 128, 128),
+            (2, 2, 2, 64, 128, 128),
+            (1, 1, 1, 32, 32, 32),
+            (1, 1, 1, 32, 128, 128),
+            (1, 1, 1, 32, 128, 128),
+            (1, 1, 1, 128, 128, 64),
+            (1, 1, 1, 32, 128, 258),
+            (1, 2, 2, 64, 128, 15),
+            (1, 1, 1, 32, 8, 17),
+            (1, 1, 1, 64, 17, 49),
+            (2, 4, 4, 32, 128, 237),
+            (2, 4, 2, 32, 128, 237),
+            (2, 4, 1, 32, 128, 237),
+            (4, 3, 3, 64, 256, 33),
+            (4, 3, 1, 64, 256, 33),
+            (1, 1, 1, 128, 128, 75),
+            (1, 1, 1, 32, 125, 444),
+            (1, 2, 2, 64, 125, 231),
+            (1, 2, 1, 64, 125, 231),
+            (1, 1, 1, 128, 256, 10240),
+            (1, 1, 1, 32, 128, 4096),
+            (1, 1, 1, 128, 3584, 381),
+            (1, 1, 1, 128, 12072, 1680),
+        ]
+        for (
+            batch,
+            heads,
+            heads_kv,
+            head_dim,
+            seqlen_q,
+            seqlen_kv,
+        ) in problem_sizes:
+            for is_causal in [False, True]:
+                self._test_backend_against_torch_sdpa(
+                    batch=batch,
+                    heads=heads,
+                    heads_kv=heads_kv,
+                    head_dim=head_dim,
+                    seqlen_q=seqlen_q,
+                    seqlen_kv=seqlen_kv,
+                    is_causal=is_causal,
+                    backend="flash3",
+                )
+
+    @pytest.mark.L1
+    @skip_if_flash3_not_supported()
+    @skip_if_not_hopper()
+    def test_flash3_randsweep(self):
+        self._test_randsweep_against_torch_sdpa(backend="flash3", max_tests=RAND_SWEEP_TESTS)
+
+
+if __name__ == "__main__":
+    random.seed(42)
+    torch.manual_seed(42)
+    unittest.main()

REGEN-main/cosmos_policy/_src/imaginaire/attention/tests/torch_compile_test.py

@@ -0,0 +1,365 @@
+#################################################################################################
+# Copyright (c) 2022-2025 Ali Hassani.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+#################################################################################################
+
+import unittest
+from functools import partial
+
+import pytest
+import torch
+from torch import nn
+
+from cosmos_policy._src.imaginaire.attention import attention as i4_attention
+from cosmos_policy._src.imaginaire.attention.flash2 import FLASH2_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.natten import NATTEN_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.utils import is_blackwell_dc, is_hopper
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+from cosmos_policy._src.imaginaire.attention.varlen import generate_varlen_parameters
+
+skip_if_natten_not_supported = partial(
+    pytest.mark.skipif,
+    not NATTEN_SUPPORTED,
+    reason="NATTEN is disabled, not available, or too old in this environment.",
+)
+
+skip_if_flash2_not_supported = partial(
+    pytest.mark.skipif,
+    not FLASH2_SUPPORTED,
+    reason="Flash2 is disabled, not available, or too old in this environment.",
+)
+
+# Tests are only enabled on Hopper and Blackwell DC-class for now.
+# Will extend to other arches as we integrate more backends.
+skip_if_not_supported = partial(
+    pytest.mark.skipif,
+    not is_blackwell_dc() and not is_hopper(),
+    reason="Attention tests are only allowed for Hopper and Blackwell DC-class GPUs for now.",
+)
+
+skip_if_not_blackwell = partial(
+    pytest.mark.skipif, not is_blackwell_dc(), reason="This test is only allowed for Blackwell DC-class GPUs."
+)
+
+skip_if_not_hopper = partial(pytest.mark.skipif, not is_hopper(), reason="This test is only allowed for Hopper GPUs.")
+
+
+def reset_torch_compile(cache_size_limit):
+    # Torch compile reset and sensible settings for unit testing
+    log.debug(f"Resetting torch compile cache. New cache size limit: {cache_size_limit}")
+    torch.compiler.reset()
+    torch._dynamo.config.cache_size_limit = cache_size_limit
+    torch._dynamo.config.accumulated_recompile_limit = cache_size_limit * 4
+    torch._dynamo.config.fail_on_recompile_limit_hit = True
+
+
+def _reset_everything():
+    torch.manual_seed(42)
+    reset_torch_compile(1024)
+    torch.cuda.empty_cache()
+
+
+class Block(nn.Module):
+    def __init__(
+        self,
+        embed_dim: int,
+        num_heads: int,
+        mlp_ratio: int,
+        qkv_bias: bool = True,
+    ):
+        super().__init__()
+
+        self.embed_dim = embed_dim
+        self.mlp_ratio = mlp_ratio
+        self.mlp_dim = int(self.embed_dim * self.mlp_ratio)
+        self.num_heads = num_heads
+        self.head_dim = self.embed_dim // self.num_heads
+        self.scale = self.head_dim**-0.5
+
+        self.q = nn.Linear(self.embed_dim, self.embed_dim, bias=qkv_bias)
+        self.kv = nn.Linear(self.embed_dim, self.embed_dim * 2, bias=qkv_bias)
+        self.proj = nn.Linear(self.embed_dim, self.embed_dim)
+
+        self.mlp = nn.Sequential(
+            nn.Linear(self.embed_dim, self.mlp_dim),
+            nn.GELU(),
+            nn.Linear(self.mlp_dim, embed_dim),
+        )
+
+    def forward(self, x: torch.Tensor, c: torch.Tensor, *args, **kwargs):
+        B, sQ, D = x.shape
+        B, sK, D = c.shape
+        q = self.q(x).reshape(B, sQ, self.num_heads, self.head_dim)
+        k, v = self.kv(c).reshape(B, sK, 2, self.num_heads, self.head_dim).permute(2, 0, 1, 3, 4)
+
+        x0 = i4_attention(q, k, v, *args, **kwargs)
+        assert isinstance(x0, torch.Tensor)
+        x0 = x0.reshape(B, sQ, D)
+
+        return self.mlp(x0)
+
+
+class TorchCompileTests(unittest.TestCase):
+    def setUp(self):
+        _reset_everything()
+
+    def tearDown(self):
+        _reset_everything()
+
+    def _test_module(
+        self,
+        batch: int,
+        seqlens_Q: list[int],
+        seqlens_KV: list[int],
+        num_heads: int,
+        head_dim: int,
+        is_causal: bool,
+        causal_type: CausalType,
+        atol: float,
+        backend: str,
+        device: str = "cuda",
+        dtype: torch.dtype = torch.float16,
+    ):
+        embed_dim = num_heads * head_dim
+
+        assert len(seqlens_Q) == len(seqlens_KV)
+        assert len(seqlens_Q) >= 1
+        assert len(seqlens_Q) == 1 or batch == len(seqlens_Q)
+
+        seqlen_q = sum(seqlens_Q)
+        seqlen_kv = sum(seqlens_KV)
+        is_varlen = len(seqlens_Q) > 1
+
+        batch_ = 1 if is_varlen else batch
+        seqlens_Q_ = torch.tensor(seqlens_Q, device=device, dtype=torch.int32) if is_varlen else None
+        seqlens_KV_ = torch.tensor(seqlens_KV, device=device, dtype=torch.int32) if is_varlen else None
+
+        dummy_q = torch.randn(
+            (batch_, seqlen_q, num_heads, head_dim),
+            dtype=dtype,
+            device=device,
+            requires_grad=True,
+        )
+        dummy_kv = torch.randn(
+            (batch_, seqlen_kv, num_heads, head_dim),
+            dtype=dtype,
+            device=device,
+            requires_grad=True,
+        )
+
+        # seq maxes MUST be computed ahead of time when using torch compile
+        # because need to be copied to host
+        (
+            cumulative_seqlen_Q,
+            cumulative_seqlen_KV,
+            max_seqlen_Q,
+            max_seqlen_KV,
+        ) = generate_varlen_parameters(
+            query=dummy_q,
+            key=dummy_kv,
+            value=dummy_kv,
+            seqlens_Q=seqlens_Q_,
+            seqlens_KV=seqlens_KV_,
+        )
+
+        _reset_everything()
+
+        log.debug(
+            f"Testing torch compile on Attention module with input shapes: "
+            f"{batch=}, {num_heads=}, {head_dim=}, {seqlens_Q=}, {seqlens_KV=}, "
+            f"{is_causal=}, {causal_type=}, {dtype=}, {device=}, {backend=}."
+        )
+
+        model_eager = (
+            Block(
+                embed_dim=embed_dim,
+                mlp_ratio=2,
+                num_heads=num_heads,
+            )
+            .to(dtype)
+            .to(device)
+        )
+
+        model_compiled = torch.compile(model_eager, fullgraph=True, backend="inductor")
+
+        x = torch.randn((batch_, seqlen_q, embed_dim), dtype=dtype, device=device)
+        c = torch.randn((batch_, seqlen_kv, embed_dim), dtype=dtype, device=device)
+        dy = torch.randn((batch_, seqlen_q, embed_dim), dtype=dtype, device=device) * 0.1
+
+        x_ref = x.clone().requires_grad_(True)
+        c_ref = c.clone().requires_grad_(True)
+        dy_ref = dy.clone()
+
+        # eager
+        y_ref = model_eager(
+            x_ref,
+            c_ref,
+            is_causal=is_causal,
+            causal_type=causal_type,
+            cumulative_seqlen_Q=cumulative_seqlen_Q,
+            cumulative_seqlen_KV=cumulative_seqlen_KV,
+            max_seqlen_Q=max_seqlen_Q,
+            max_seqlen_KV=max_seqlen_KV,
+            backend=backend,
+        )
+        y_ref.backward(dy_ref)
+        dx_ref = x_ref.grad
+        dc_ref = c_ref.grad
+
+        # compile on first attempt
+        x = x.requires_grad_(True)
+        c = c.requires_grad_(True)
+        y = model_compiled(
+            x,
+            c,
+            is_causal=is_causal,
+            causal_type=causal_type,
+            cumulative_seqlen_Q=cumulative_seqlen_Q,
+            cumulative_seqlen_KV=cumulative_seqlen_KV,
+            max_seqlen_Q=max_seqlen_Q,
+            max_seqlen_KV=max_seqlen_KV,
+            backend=backend,
+        )
+        y.backward(dy)
+        dx = x.grad
+        dc = c.grad
+
+        torch.testing.assert_close(y, y_ref, atol=atol, rtol=0)
+        torch.testing.assert_close(dx, dx_ref, atol=atol, rtol=0)
+        torch.testing.assert_close(dc, dc_ref, atol=atol, rtol=0)
+
+        # Second run, just to make sure it doesn't crash
+        y = model_compiled(
+            x,
+            c,
+            is_causal=is_causal,
+            causal_type=causal_type,
+            cumulative_seqlen_Q=cumulative_seqlen_Q,
+            cumulative_seqlen_KV=cumulative_seqlen_KV,
+            max_seqlen_Q=max_seqlen_Q,
+            max_seqlen_KV=max_seqlen_KV,
+            backend=backend,
+        )
+        y.backward(dy)
+        dx = x.grad
+        dc = c.grad
+
+    @pytest.mark.L1
+    @skip_if_natten_not_supported()
+    @skip_if_not_supported()
+    def test_compiled_natten(self):
+        problem_sizes = [
+            (1, 4, 128, [128], [128]),
+            (1, 1, 128, [128], [1024]),
+            (1, 1, 128, [128], [13568]),
+            (1, 1, 128, [128], [13496]),
+            (1, 1, 32, [128], [13496]),
+            (1, 1, 32, [32], [13496]),
+            (3, 1, 32, [77], [8504]),
+            (1, 1, 32, [77], [8504]),
+            (1, 1, 64, [40], [12296]),
+            (1, 2, 64, [40], [12296]),
+            (1, 2, 64, [40], [12296]),
+            (1, 1, 128, [128], [128]),
+            (6, 1, 128, [128, 128, 135, 121, 128, 128], [128, 128, 135, 121, 128, 128]),
+            (5, 1, 128, [128, 128, 135, 128, 128], [128, 128, 135, 128, 128]),
+            (2, 1, 128, [135, 200], [128, 768]),
+            (2, 1, 128, [1024, 200], [128, 768]),
+            (2, 1, 128, [135, 200], [135, 768]),
+            (2, 1, 128, [1024, 200], [135, 768]),
+            (2, 1, 128, [1024, 256], [128, 768]),
+            (4, 1, 128, [1024, 8, 17, 2048], [10, 20, 512, 16]),
+            (3, 2, 128, [268, 1584, 1571], [2448, 4088, 1925]),
+            (2, 1, 128, [1024, 256], [512, 768]),
+        ]
+        for (
+            batch,
+            num_heads,
+            head_dim,
+            seqlens_Q,
+            seqlens_KV,
+        ) in problem_sizes:
+            for is_causal in [False, True]:
+                self._test_module(
+                    batch=batch,
+                    seqlens_Q=seqlens_Q,
+                    seqlens_KV=seqlens_KV,
+                    num_heads=num_heads,
+                    head_dim=head_dim,
+                    is_causal=is_causal,
+                    causal_type=CausalType.TopLeft,
+                    atol=1e-3,
+                    backend="natten",
+                )
+
+    @pytest.mark.L1
+    @skip_if_flash2_not_supported()
+    @skip_if_not_supported()
+    def test_compiled_flash2(self):
+        problem_sizes = [
+            (1, 4, 128, [128], [128]),
+            (1, 1, 128, [128], [1024]),
+            (1, 1, 128, [128], [13568]),
+            (1, 1, 128, [128], [13496]),
+            (1, 1, 32, [128], [13496]),
+            (1, 1, 32, [32], [13496]),
+            (3, 1, 32, [77], [8504]),
+            (1, 1, 32, [77], [8504]),
+            (1, 1, 64, [40], [12296]),
+            (1, 2, 64, [40], [12296]),
+            (1, 2, 64, [40], [12296]),
+            (1, 1, 128, [128], [128]),
+            (6, 1, 128, [128, 128, 135, 121, 128, 128], [128, 128, 135, 121, 128, 128]),
+            (5, 1, 128, [128, 128, 135, 128, 128], [128, 128, 135, 128, 128]),
+            (2, 1, 128, [135, 200], [128, 768]),
+            (2, 1, 128, [1024, 200], [128, 768]),
+            (2, 1, 128, [135, 200], [135, 768]),
+            (2, 1, 128, [1024, 200], [135, 768]),
+            (2, 1, 128, [1024, 256], [128, 768]),
+            (4, 1, 128, [1024, 8, 17, 2048], [10, 20, 512, 16]),
+            (3, 2, 128, [268, 1584, 1571], [2448, 4088, 1925]),
+            (2, 1, 128, [1024, 256], [512, 768]),
+        ]
+        for (
+            batch,
+            num_heads,
+            head_dim,
+            seqlens_Q,
+            seqlens_KV,
+        ) in problem_sizes:
+            for is_causal in [False, True]:
+                self._test_module(
+                    batch=batch,
+                    seqlens_Q=seqlens_Q,
+                    seqlens_KV=seqlens_KV,
+                    num_heads=num_heads,
+                    head_dim=head_dim,
+                    is_causal=is_causal,
+                    causal_type=CausalType.BottomRight,
+                    atol=1e-3,
+                    backend="flash2",
+                )
+
+
+if __name__ == "__main__":
+    torch.manual_seed(42)
+    unittest.main()

REGEN-main/cosmos_policy/_src/imaginaire/attention/tests/varlen_test.py

@@ -0,0 +1,711 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+SDPA unit tests.
+"""
+
+import random
+import unittest
+from functools import partial
+
+import pytest
+import torch
+
+from cosmos_policy._src.imaginaire.attention import attention as i4_attention
+from cosmos_policy._src.imaginaire.attention.flash2 import FLASH2_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.flash3 import FLASH3_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.masks import CausalType
+from cosmos_policy._src.imaginaire.attention.natten import NATTEN_SUPPORTED
+from cosmos_policy._src.imaginaire.attention.utils import is_blackwell_dc, is_fp8, is_hopper
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+
+RAND_SWEEP_TESTS = 1000
+
+skip_if_natten_not_supported = partial(
+    pytest.mark.skipif,
+    not NATTEN_SUPPORTED,
+    reason="NATTEN is disabled, not available, or too old in this environment.",
+)
+
+skip_if_flash2_not_supported = partial(
+    pytest.mark.skipif,
+    not FLASH2_SUPPORTED,
+    reason="Flash2 is disabled, not available, or too old in this environment.",
+)
+
+skip_if_flash3_not_supported = partial(
+    pytest.mark.skipif,
+    not FLASH3_SUPPORTED,
+    reason="Flash3 is disabled, not available, or too old in this environment.",
+)
+
+# Tests are only enabled on Hopper and Blackwell DC-class for now.
+# Will extend to other arches as we integrate more backends.
+skip_if_not_supported = partial(
+    pytest.mark.skipif,
+    not is_blackwell_dc() and not is_hopper(),
+    reason="SDPA tests are only allowed for Hopper and Blackwell DC-class GPUs for now.",
+)
+
+skip_if_not_blackwell = partial(
+    pytest.mark.skipif, not is_blackwell_dc(), reason="This test is only allowed for Blackwell DC-class GPUs."
+)
+
+skip_if_not_hopper = partial(pytest.mark.skipif, not is_hopper(), reason="This test is only allowed for Hopper GPUs.")
+
+
+def _reset_everything():
+    torch.manual_seed(42)
+    torch.cuda.empty_cache()
+
+
+# Computes varlen by breaking up into individual attention calls
+def compute_split_reference(
+    batch: int,
+    heads: int,
+    head_dim: int,
+    seqlens_Q_list: list[int],
+    seqlens_KV_list: list[int],
+    is_causal: bool,
+    causal_type: CausalType | None,
+    backend: str,
+    test_backward: bool,
+    dtype: torch.dtype = torch.float32,
+    heads_kv: int | None = None,
+    head_dim_v: int | None = None,
+    backend_kwargs: dict | None = None,
+):
+    heads_kv = heads_kv or heads
+    head_dim_v = head_dim_v or head_dim
+
+    assert len(seqlens_Q_list) == len(seqlens_KV_list) == batch
+
+    seqlen_q_total = sum(seqlens_Q_list)
+    seqlen_kv_total = sum(seqlens_KV_list)
+    dtype_safe = torch.float16
+    with torch.no_grad():
+        q_ref, k_ref, v_ref, d_out_ref = (
+            torch.randn((1, seqlen_q_total, heads, head_dim), device="cuda", dtype=dtype_safe).to(dtype),
+            torch.randn(
+                (1, seqlen_kv_total, heads_kv, head_dim),
+                device="cuda",
+                dtype=dtype_safe,
+            ).to(dtype),
+            torch.randn(
+                (1, seqlen_kv_total, heads_kv, head_dim_v),
+                device="cuda",
+                dtype=dtype_safe,
+            ).to(dtype),
+            torch.randn((1, seqlen_q_total, heads, head_dim_v), device="cuda", dtype=dtype_safe).to(dtype),
+        )
+        q, k, v, d_out = (
+            q_ref.clone(),
+            k_ref.clone(),
+            v_ref.clone(),
+            d_out_ref.clone(),
+        )
+
+    out_list = []
+    lse_list = []
+    d_q_list = []
+    d_k_list = []
+    d_v_list = []
+
+    q_start, kv_start = 0, 0
+    for b in range(batch):
+        seqlen_q = seqlens_Q_list[b]
+        seqlen_kv = seqlens_KV_list[b]
+
+        q_ = q_ref[:, q_start : q_start + seqlen_q, :, :].clone()
+        k_ = k_ref[:, kv_start : kv_start + seqlen_kv, :, :].clone()
+        v_ = v_ref[:, kv_start : kv_start + seqlen_kv, :, :].clone()
+
+        if test_backward:
+            q_ = q_.requires_grad_(True)
+            k_ = k_.requires_grad_(True)
+            v_ = v_.requires_grad_(True)
+            d_out_ = d_out_ref[:, q_start : q_start + seqlen_q, :, :].clone().requires_grad_(True)
+
+        out_, lse_ = i4_attention(
+            q_,
+            k_,
+            v_,
+            is_causal=is_causal,
+            causal_type=causal_type,
+            backend=backend,
+            backend_kwargs=backend_kwargs,
+            return_lse=True,
+        )
+
+        if test_backward:
+            out_.backward(d_out_)
+
+        with torch.no_grad():
+            out_list.append(out_.data.clone().float())
+            lse_list.append(lse_.data.clone().float())
+            if test_backward:
+                assert q_.grad is not None
+                assert k_.grad is not None
+                assert v_.grad is not None
+                d_q_list.append(q_.grad.clone().float())
+                d_k_list.append(k_.grad.clone().float())
+                d_v_list.append(v_.grad.clone().float())
+
+        q_start += seqlen_q
+        kv_start += seqlen_kv
+
+    assert q_start == seqlen_q_total
+    assert kv_start == seqlen_kv_total
+
+    out_ref = torch.cat(out_list, dim=1)
+    lse_ref = torch.cat(lse_list, dim=1)
+    assert out_ref.shape[:3] == q_ref.shape[:3]
+    dq_ref = None
+    dk_ref = None
+    dv_ref = None
+    if test_backward:
+        dq_ref = torch.cat(d_q_list, dim=1)
+        dk_ref = torch.cat(d_k_list, dim=1)
+        dv_ref = torch.cat(d_v_list, dim=1)
+
+        assert dq_ref.shape == q_ref.shape
+        assert dk_ref.shape == k_ref.shape
+        assert dv_ref.shape == v_ref.shape
+
+    return (q, k, v, d_out), (out_ref, lse_ref, dq_ref, dk_ref, dv_ref)
+
+
+class VarlenTest(unittest.TestCase):
+    def setUp(self):
+        _reset_everything()
+
+    def tearDown(self):
+        _reset_everything()
+
+    def _test_against_manual_varlen(
+        self,
+        batch: int,
+        heads: int,
+        head_dim: int,
+        seqlens_Q_list: list[int],
+        seqlens_KV_list: list[int],
+        is_causal: bool,
+        causal_type: CausalType | None,
+        dtype: torch.dtype,
+        atol_fwd: tuple[float, float],
+        atol_bwd: tuple[float, float, float] | None,
+        backend: str,
+        reference_backend: str,
+        test_backward: bool,
+        heads_kv: int | None = None,
+        head_dim_v: int | None = None,
+        reference_backend_kwargs: dict | None = None,
+        backend_kwargs: dict | None = None,
+    ):
+        heads_kv = heads_kv or heads
+        head_dim_v = head_dim_v or head_dim
+
+        log.debug(
+            f"Testing varlen ({backend}) against manual varlen ({reference_backend}): "
+            f"{batch=}, {heads=}, {heads_kv=}, {head_dim=}, {head_dim_v=}, "
+            f"{seqlens_Q_list=}, {seqlens_KV_list=}, {is_causal=}, {causal_type=}, {dtype=}."
+        )
+
+        inputs, reference = compute_split_reference(
+            batch=batch,
+            heads=heads,
+            heads_kv=heads_kv,
+            head_dim=head_dim,
+            head_dim_v=head_dim_v,
+            seqlens_Q_list=seqlens_Q_list,
+            seqlens_KV_list=seqlens_KV_list,
+            is_causal=is_causal,
+            causal_type=causal_type,
+            dtype=dtype,
+            backend=reference_backend,
+            backend_kwargs=reference_backend_kwargs,
+            test_backward=test_backward,
+        )
+
+        q, k, v, d_out = inputs
+        out_ref, lse_ref, dq_ref, dk_ref, dv_ref = reference
+        q = q.to(dtype)
+        k = k.to(dtype)
+        v = v.to(dtype)
+        d_out = d_out.to(dtype)
+
+        # Run target
+        if test_backward:
+            q.requires_grad_(test_backward)
+            k.requires_grad_(test_backward)
+            v.requires_grad_(test_backward)
+            d_out.requires_grad_(test_backward)
+
+        seqlens_Q = torch.tensor(seqlens_Q_list, dtype=torch.int32, device=q.device)
+        seqlens_KV = torch.tensor(seqlens_KV_list, dtype=torch.int32, device=q.device)
+
+        out_, lse_ = i4_attention(
+            q,
+            k,
+            v,
+            is_causal=is_causal,
+            causal_type=causal_type,
+            backend=backend,
+            return_lse=True,
+            seqlens_Q=seqlens_Q,
+            seqlens_KV=seqlens_KV,
+            backend_kwargs=backend_kwargs,
+        )
+        out = out_.float()
+        lse = lse_.float()
+
+        if test_backward:
+            dq, dk, dv = None, None, None
+            out_.backward(d_out)
+            with torch.no_grad():
+                dq, dk, dv = (
+                    q.grad.clone().float(),
+                    k.grad.clone().float(),
+                    v.grad.clone().float(),
+                )
+
+        atol_out, atol_lse = atol_fwd
+        assert out.shape == out_ref.shape
+
+        torch.testing.assert_close(out, out_ref, atol=atol_out, rtol=0)
+        torch.testing.assert_close(lse, lse_ref, atol=atol_lse, rtol=0)
+
+        if test_backward:
+            assert atol_bwd is not None
+            atol_dq, atol_dk, atol_dv = atol_bwd
+            torch.testing.assert_close(dq, dq_ref, atol=atol_dq, rtol=0)
+            torch.testing.assert_close(dk, dk_ref, atol=atol_dk, rtol=0)
+            torch.testing.assert_close(dv, dv_ref, atol=atol_dv, rtol=0)
+
+    def _test_natten_varlen(
+        self,
+        batch: int,
+        heads: int,
+        head_dim: int,
+        seqlens_Q_list: list[int],
+        seqlens_KV_list: list[int],
+        is_causal: bool,
+        head_dim_v: int | None = None,
+        heads_kv: int | None = None,
+    ):
+        torch.set_default_device("cuda")
+
+        # We're testing against the same backend and same dtype,
+        # but with varlen implemented as multiple kernel calls, so
+        # error thresholds should be much smaller here.
+        # This is therefore only a test of the varlen functionality.
+        # Correctness per dtype is expected to be verified in the main
+        # fmha tests.
+        # dQ still needs a more relaxed threshold because of the non-determinism
+        ALLOWED_DTYPES = [
+            # dtype, (atol_out, atol_lse), (atol_dq, atol_dk, atol_dv)
+            (torch.float16, (1e-6, 1e-6), (1e-2, 1e-6, 1e-6)),
+            (torch.bfloat16, (1e-6, 1e-6), (1e-2, 1e-6, 1e-6)),
+        ]
+
+        if is_blackwell_dc():
+            ALLOWED_DTYPES += [
+                (torch.float8_e4m3fn, (1e-6, 1e-6), None),
+                (torch.float8_e5m2, (1e-6, 1e-6), None),
+            ]
+
+        # NOTE: Hopper FMHA does not support varlen, so natten falls back
+        # to cutlass-fmha, which means the reference may target hopper-fmha,
+        # while the varlen target is cutlass-fmha, and this will throw off the
+        # error limits.
+        backend_kwargs = None
+        if is_hopper():
+            backend_kwargs = {"backend": "cutlass-fmha"}
+
+        for dtype, atol_fwd, atol_bwd in ALLOWED_DTYPES:
+            self._test_against_manual_varlen(
+                batch=batch,
+                heads=heads,
+                heads_kv=heads_kv,
+                head_dim=head_dim,
+                head_dim_v=head_dim_v,
+                seqlens_Q_list=seqlens_Q_list,
+                seqlens_KV_list=seqlens_KV_list,
+                is_causal=is_causal,
+                causal_type=CausalType.TopLeft,  # Top-left is the only supported mask in natten (for now)
+                dtype=dtype,
+                atol_fwd=atol_fwd,
+                atol_bwd=atol_bwd,
+                backend="natten",
+                reference_backend="natten",
+                backend_kwargs=backend_kwargs,
+                reference_backend_kwargs=backend_kwargs,
+                test_backward=not is_fp8(dtype),
+            )
+
+    def _test_flash2_varlen(
+        self,
+        batch: int,
+        heads: int,
+        head_dim: int,
+        seqlens_Q_list: list[int],
+        seqlens_KV_list: list[int],
+        is_causal: bool,
+        head_dim_v: int | None = None,
+        heads_kv: int | None = None,
+    ):
+        torch.set_default_device("cuda")
+
+        # we can't quite pull the same trick as in natten -- apparently the kernel
+        # configs for varlen and non-varlen cases are very different.
+        # Setting deterministic=True doesn't seem to help either
+        backend_kwargs = None
+        # backend_kwargs = {"deterministic": True}
+        ALLOWED_DTYPES = [
+            # dtype, (atol_out, atol_lse), (atol_dq, atol_dk, atol_dv)
+            (torch.float16, (1e-2, 1e-2), (1e-1, 1e-2, 1e-2)),
+            (torch.bfloat16, (1e-1, 1e-2), (1e-1, 1e-1, 1e-1)),
+        ]
+
+        for dtype, atol_fwd, atol_bwd in ALLOWED_DTYPES:
+            self._test_against_manual_varlen(
+                batch=batch,
+                heads=heads,
+                heads_kv=heads_kv,
+                head_dim=head_dim,
+                head_dim_v=head_dim_v,
+                seqlens_Q_list=seqlens_Q_list,
+                seqlens_KV_list=seqlens_KV_list,
+                is_causal=is_causal,
+                causal_type=CausalType.BottomRight,  # Bottom-right is the only supported mask in flash2
+                dtype=dtype,
+                atol_fwd=atol_fwd,
+                atol_bwd=atol_bwd,
+                backend="flash2",
+                reference_backend="flash2",
+                backend_kwargs=backend_kwargs,
+                reference_backend_kwargs=backend_kwargs,
+                test_backward=True,
+            )
+
+    def _test_flash3_varlen(
+        self,
+        batch: int,
+        heads: int,
+        head_dim: int,
+        seqlens_Q_list: list[int],
+        seqlens_KV_list: list[int],
+        is_causal: bool,
+        head_dim_v: int | None = None,
+        heads_kv: int | None = None,
+    ):
+        torch.set_default_device("cuda")
+
+        # We're testing against the same backend and same dtype,
+        # but with varlen implemented as multiple kernel calls, so
+        # error thresholds should be much smaller here.
+        # This is therefore only a test of the varlen functionality.
+        # Correctness per dtype is expected to be verified in the main
+        # fmha tests.
+        # dQ still needs a more relaxed threshold because of the non-determinism
+        ALLOWED_DTYPES = [
+            # dtype, (atol_out, atol_lse), (atol_dq, atol_dk, atol_dv)
+            (torch.float16, (1e-6, 1e-6), (1e-2, 1e-6, 1e-6)),
+            (torch.bfloat16, (1e-6, 1e-6), (1e-2, 1e-6, 1e-6)),
+        ]
+        backend_kwargs = None
+
+        # GQA/MQA introduce some extra non determinism (possibly due to extra reduction step?)
+        if heads_kv is not None and heads != heads_kv:
+            ALLOWED_DTYPES = [
+                # dtype, (atol_out, atol_lse), (atol_dq, atol_dk, atol_dv)
+                (torch.float16, (1e-6, 1e-6), (1e-2, 1e-1, 1e-1)),
+                (torch.bfloat16, (1e-6, 1e-6), (1e-2, 1e-1, 1e-1)),
+            ]
+            backend_kwargs = {"deterministic": True}
+
+        for dtype, atol_fwd, atol_bwd in ALLOWED_DTYPES:
+            self._test_against_manual_varlen(
+                batch=batch,
+                heads=heads,
+                heads_kv=heads_kv,
+                head_dim=head_dim,
+                head_dim_v=head_dim_v,
+                seqlens_Q_list=seqlens_Q_list,
+                seqlens_KV_list=seqlens_KV_list,
+                is_causal=is_causal,
+                causal_type=CausalType.BottomRight,  # Bottom-right is the only supported mask in flash3
+                dtype=dtype,
+                atol_fwd=atol_fwd,
+                atol_bwd=atol_bwd,
+                backend="flash3",
+                reference_backend="flash3",
+                backend_kwargs=backend_kwargs,
+                reference_backend_kwargs=backend_kwargs,
+                test_backward=True,
+            )
+
+    def _test_varlen(
+        self,
+        batch: int,
+        heads: int,
+        head_dim: int,
+        seqlens_Q_list: list[int],
+        seqlens_KV_list: list[int],
+        is_causal: bool,
+        backend: str,
+        head_dim_v: int | None = None,
+        heads_kv: int | None = None,
+    ):
+        if backend == "natten":
+            self._test_natten_varlen(
+                batch=batch,
+                heads=heads,
+                heads_kv=heads_kv,
+                head_dim=head_dim,
+                head_dim_v=head_dim_v,
+                seqlens_Q_list=seqlens_Q_list,
+                seqlens_KV_list=seqlens_KV_list,
+                is_causal=is_causal,
+            )
+        elif backend == "flash2":
+            self._test_flash2_varlen(
+                batch=batch,
+                heads=heads,
+                heads_kv=heads_kv,
+                head_dim=head_dim,
+                head_dim_v=head_dim_v,
+                seqlens_Q_list=seqlens_Q_list,
+                seqlens_KV_list=seqlens_KV_list,
+                is_causal=is_causal,
+            )
+        elif backend == "flash3":
+            self._test_flash3_varlen(
+                batch=batch,
+                heads=heads,
+                heads_kv=heads_kv,
+                head_dim=head_dim,
+                head_dim_v=head_dim_v,
+                seqlens_Q_list=seqlens_Q_list,
+                seqlens_KV_list=seqlens_KV_list,
+                is_causal=is_causal,
+            )
+        else:
+            raise NotImplementedError()
+
+    def _test_varlen_randsweep(self, backend: str, max_tests: int = 1000):
+        random.seed(42)
+
+        max_seqlen = 2**17
+        for i in range(max_tests):
+            batch = random.choice(range(1, 12))
+
+            supports_gqa_mqa = False
+            if backend == "natten":
+                head_dim_choices = [32, 64, 128]
+                heads_choices = range(1, 8 + 1)
+                # GQA/MQA is only supported in NATTEN's Blackwell FMHA backend for now
+                supports_gqa_mqa = is_blackwell_dc()
+            elif backend in ["flash2", "flash3"]:
+                head_dim_choices = range(16, 256 + 1, 8)
+                heads_choices = range(1, 8 + 1)
+                supports_gqa_mqa = True
+            else:
+                raise NotImplementedError()
+
+            heads = random.choice(heads_choices)
+            heads_kv = (
+                heads
+                if not supports_gqa_mqa
+                else random.choice([1] + [i for i in range(1, heads + 1) if heads % i == 0])
+            )
+            assert heads >= heads_kv and heads % heads_kv == 0
+
+            head_dim = random.choice(head_dim_choices)
+            head_dim_v = None
+
+            seqlens_Q_list = []
+            seqlens_KV_list = []
+            for i in range(batch):
+                max_q = min(2**12, max(max_seqlen - sum(seqlens_Q_list), 24))
+                max_k = min(2**12, max(max_seqlen - sum(seqlens_KV_list), 24))
+                new_q = random.choice(range(8, max_q, 1))
+                new_k = random.choice(range(8, max_k, 1))
+                seqlens_Q_list.append(new_q)
+                seqlens_KV_list.append(new_k)
+
+            for is_causal in [False, True]:
+                self._test_varlen(
+                    batch=batch,
+                    heads=heads,
+                    heads_kv=heads_kv,
+                    head_dim=head_dim,
+                    head_dim_v=head_dim_v,
+                    seqlens_Q_list=seqlens_Q_list,
+                    seqlens_KV_list=seqlens_KV_list,
+                    is_causal=is_causal,
+                    backend=backend,
+                )
+
+    @pytest.mark.L1
+    @skip_if_natten_not_supported()
+    @skip_if_not_supported()
+    def test_natten_varlen_fast(self):
+        problem_sizes = [
+            (
+                9,
+                4,
+                128,
+                [2669, 2240, 910, 2421, 3323, 34, 3308, 2867, 1401],
+                [2880, 1726, 1847, 1147, 3568, 3116, 661, 1739, 1146],
+            ),
+            (6, 1, 128, [128, 128, 135, 121, 128, 128], [128, 128, 135, 121, 128, 128]),
+            (5, 1, 128, [128, 128, 135, 128, 128], [128, 128, 135, 128, 128]),
+            (2, 1, 128, [135, 200], [128, 768]),
+            (2, 1, 128, [1024, 200], [128, 768]),
+            (2, 1, 128, [135, 200], [135, 768]),
+            (2, 1, 128, [1024, 200], [135, 768]),
+            (2, 1, 128, [1024, 256], [128, 768]),
+            (4, 1, 128, [1024, 8, 17, 2048], [10, 20, 512, 16]),
+            (3, 2, 128, [268, 1584, 1571], [2448, 4088, 1925]),
+            (2, 1, 128, [1024, 256], [512, 768]),
+        ]
+        for (
+            batch,
+            heads,
+            head_dim,
+            seqlens_Q_list,
+            seqlens_KV_list,
+        ) in problem_sizes:
+            for is_causal in [False, True]:
+                self._test_varlen(
+                    batch=batch,
+                    heads=heads,
+                    head_dim=head_dim,
+                    seqlens_Q_list=seqlens_Q_list,
+                    seqlens_KV_list=seqlens_KV_list,
+                    is_causal=is_causal,
+                    backend="natten",
+                )
+
+    @pytest.mark.L1
+    @skip_if_natten_not_supported()
+    @skip_if_not_supported()
+    def test_natten_varlen_randsweep(self):
+        self._test_varlen_randsweep(backend="natten", max_tests=RAND_SWEEP_TESTS)
+
+    @pytest.mark.L1
+    @skip_if_flash2_not_supported()
+    @skip_if_not_supported()
+    def test_flash2_varlen_fast(self):
+        problem_sizes = [
+            (
+                9,
+                4,
+                128,
+                [2669, 2240, 910, 2421, 3323, 34, 3308, 2867, 1401],
+                [2880, 1726, 1847, 1147, 3568, 3116, 661, 1739, 1146],
+            ),
+            (6, 1, 128, [128, 128, 135, 121, 128, 128], [128, 128, 135, 121, 128, 128]),
+            (5, 1, 128, [128, 128, 135, 128, 128], [128, 128, 135, 128, 128]),
+            (2, 1, 128, [135, 200], [128, 768]),
+            (2, 1, 128, [1024, 200], [128, 768]),
+            (2, 1, 128, [135, 200], [135, 768]),
+            (2, 1, 128, [1024, 200], [135, 768]),
+            (2, 1, 128, [1024, 256], [128, 768]),
+            (4, 1, 128, [1024, 8, 17, 2048], [10, 20, 512, 16]),
+            (3, 2, 128, [268, 1584, 1571], [2448, 4088, 1925]),
+            (2, 1, 128, [1024, 256], [512, 768]),
+        ]
+        for (
+            batch,
+            heads,
+            head_dim,
+            seqlens_Q_list,
+            seqlens_KV_list,
+        ) in problem_sizes:
+            for is_causal in [False, True]:
+                self._test_varlen(
+                    batch=batch,
+                    heads=heads,
+                    head_dim=head_dim,
+                    seqlens_Q_list=seqlens_Q_list,
+                    seqlens_KV_list=seqlens_KV_list,
+                    is_causal=is_causal,
+                    backend="flash2",
+                )
+
+    @pytest.mark.L1
+    @skip_if_flash2_not_supported()
+    @skip_if_not_supported()
+    def test_flash2_varlen_randsweep(self):
+        self._test_varlen_randsweep(backend="flash2", max_tests=RAND_SWEEP_TESTS)
+
+    @pytest.mark.L1
+    @skip_if_flash3_not_supported()
+    @skip_if_not_hopper()
+    def test_flash3_varlen_fast(self):
+        problem_sizes = [
+            (
+                9,
+                4,
+                128,
+                [2669, 2240, 910, 2421, 3323, 34, 3308, 2867, 1401],
+                [2880, 1726, 1847, 1147, 3568, 3116, 661, 1739, 1146],
+            ),
+            (6, 1, 128, [128, 128, 135, 121, 128, 128], [128, 128, 135, 121, 128, 128]),
+            (5, 1, 128, [128, 128, 135, 128, 128], [128, 128, 135, 128, 128]),
+            (2, 1, 128, [135, 200], [128, 768]),
+            (2, 1, 128, [1024, 200], [128, 768]),
+            (2, 1, 128, [135, 200], [135, 768]),
+            (2, 1, 128, [1024, 200], [135, 768]),
+            (2, 1, 128, [1024, 256], [128, 768]),
+            (4, 1, 128, [1024, 8, 17, 2048], [10, 20, 512, 16]),
+            (3, 2, 128, [268, 1584, 1571], [2448, 4088, 1925]),
+            (2, 1, 128, [1024, 256], [512, 768]),
+        ]
+        for (
+            batch,
+            heads,
+            head_dim,
+            seqlens_Q_list,
+            seqlens_KV_list,
+        ) in problem_sizes:
+            for is_causal in [False, True]:
+                self._test_varlen(
+                    batch=batch,
+                    heads=heads,
+                    head_dim=head_dim,
+                    seqlens_Q_list=seqlens_Q_list,
+                    seqlens_KV_list=seqlens_KV_list,
+                    is_causal=is_causal,
+                    backend="flash3",
+                )
+
+    @pytest.mark.L1
+    @skip_if_flash3_not_supported()
+    @skip_if_not_hopper()
+    def test_flash3_varlen_randsweep(self):
+        self._test_varlen_randsweep(backend="flash3", max_tests=RAND_SWEEP_TESTS)
+
+
+if __name__ == "__main__":
+    random.seed(42)
+    torch.manual_seed(42)
+    unittest.main()

REGEN-main/cosmos_policy/_src/imaginaire/attention/utils/__init__.py

@@ -0,0 +1,83 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Utilities: compute capability detection, helpers, and more.
+"""
+
+from typing import Any
+
+import torch
+
+from cosmos_policy._src.imaginaire.attention.utils import safe_log as log
+from cosmos_policy._src.imaginaire.attention.utils.environment import is_torch_compiling
+
+
+def get_arch_tag(device: torch.device | None = None) -> int:
+    """
+    Returns the compute capability of a given torch device if it's a CUDA device, otherwise returns 0.
+
+    Args:
+        device (torch.device | None): torch device. Uses default device if None.
+
+    Returns:
+        device_cc (int): compute capability in the SmXXX format (i.e. 90 for Hopper).
+    """
+    if torch.cuda.is_available() and torch.version.cuda and (device is None or device.type == "cuda"):
+        major, minor = torch.cuda.get_device_capability(device)
+        return major * 10 + minor
+    return 0
+
+
+def log_or_raise_error(msg: str, raise_error: bool = False, exception: Any = RuntimeError):
+    if raise_error:
+        raise exception(msg)
+    else:
+        log.debug(msg)
+
+
+def is_full(dtype: torch.dtype) -> bool:
+    return dtype == torch.float32
+
+
+def is_half(dtype: torch.dtype) -> bool:
+    return dtype in [torch.float16, torch.bfloat16]
+
+
+def is_fp8(dtype: torch.dtype) -> bool:
+    return dtype in [torch.float8_e5m2, torch.float8_e4m3fn]
+
+
+def is_hopper(device: torch.device | None = None) -> bool:
+    return get_arch_tag(device) == 90
+
+
+def is_blackwell_dc(device: torch.device | None = None) -> bool:
+    return get_arch_tag(device) in [100, 103]
+
+
+__all__ = [
+    "get_arch_tag",
+    "log_or_raise_error",
+    "is_full",
+    "is_half",
+    "is_fp8",
+    "is_hopper",
+    "is_blackwell_dc",
+    "is_torch_compiling",
+]

REGEN-main/cosmos_policy/_src/imaginaire/attention/utils/environment.py

@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Environment-related utilities.
+"""
+
+import torch
+
+from cosmos_policy._src.imaginaire.utils import log
+
+
+# Controls all regions guarded against torch compile
+# Logs, and certain assertions cause graph breaks.
+def is_torch_compiling() -> bool:
+    try:
+        return torch.compiler.is_compiling()
+    except Exception as e:
+        log.exception(f"Exception occurred checking whether in torch compiled region: {e}")
+        # Assume too old to support torch compile
+        return False

REGEN-main/cosmos_policy/_src/imaginaire/attention/utils/safe_log.py

@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Safe logging utilities: logging should be disabled when in a torch.compiled
+region.
+"""
+
+from cosmos_policy._src.imaginaire.attention.utils.environment import is_torch_compiling
+from cosmos_policy._src.imaginaire.utils import log
+
+
+def trace(message: str, rank0_only: bool = True) -> None:
+    if not is_torch_compiling():
+        log.trace(message=message, rank0_only=rank0_only)
+
+
+def debug(message: str, rank0_only: bool = True) -> None:
+    if not is_torch_compiling():
+        log.debug(message=message, rank0_only=rank0_only)
+
+
+def info(message: str, rank0_only: bool = True) -> None:
+    if not is_torch_compiling():
+        log.info(message=message, rank0_only=rank0_only)
+
+
+def success(message: str, rank0_only: bool = True) -> None:
+    if not is_torch_compiling():
+        log.success(message=message, rank0_only=rank0_only)
+
+
+def warning(message: str, rank0_only: bool = True) -> None:
+    if not is_torch_compiling():
+        log.warning(message=message, rank0_only=rank0_only)
+
+
+def error(message: str, rank0_only: bool = True) -> None:
+    if not is_torch_compiling():
+        log.critical(message=message, rank0_only=rank0_only)
+
+
+def critical(message: str, rank0_only: bool = True) -> None:
+    if not is_torch_compiling():
+        log.critical(message=message, rank0_only=rank0_only)
+
+
+def exception(message: str, rank0_only: bool = True) -> None:
+    if not is_torch_compiling():
+        log.exception(message=message, rank0_only=rank0_only)

REGEN-main/cosmos_policy/_src/imaginaire/attention/varlen.py

@@ -0,0 +1,120 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Imaginaire4 Attention Subpackage:
+Unified implementation for all Attention implementations.
+
+Varlen utilities
+"""
+
+import torch
+from torch import Tensor
+
+from cosmos_policy._src.imaginaire.attention.utils import is_torch_compiling
+
+
+def generate_varlen_parameters(
+    query: Tensor,
+    key: Tensor,
+    value: Tensor,
+    seqlens_Q: Tensor | None = None,
+    seqlens_KV: Tensor | None = None,
+) -> tuple[None, None, int, int] | tuple[Tensor, Tensor, int, int]:
+    # NOTE: max_seqlen_{Q,KV} require a device-host sync, since they're expected to be ints (with
+    # which we launch the varlen kernel) and not device tensors.
+    # .item() introduces control flow and breaks the graph.
+    # It is also inefficient to repeat this per-op, and mostly there for convenience.
+    # generate_varlen_parameters should ideally always be called by the user ahead of model
+    # forward / backward.
+    if is_torch_compiling():
+        raise RuntimeError(
+            "Running 'generate_varlen_parameters' in a torch-compiled region is disallowed as it "
+            "results in graph breaks. Please consider calling ahead of time and pass "
+            "'cumulative_seqlen_{Q,KV}' and 'max_seqlen_{Q,KV}' instead of 'seqlens_{Q,KV}' to "
+            "'attention'. "
+        )
+
+    if query.shape[0] != key.shape[0] or query.shape[0] != value.shape[0]:
+        raise ValueError(
+            f"Q, K, and V must match in batch size, got {query.shape[0]=}, {key.shape[0]=}, {value.shape[0]=}."
+        )
+
+    if (seqlens_Q is None) ^ (seqlens_KV is None):
+        raise ValueError(
+            "Variable length Attention requires both of seqlens_Q and seqlens_KV to be set, got "
+            f"{seqlens_Q=}, {seqlens_KV=}."
+        )
+
+    if seqlens_Q is None and seqlens_KV is None:
+        # Not varlen
+        return None, None, 0, 0
+
+    assert seqlens_Q is not None
+    assert seqlens_KV is not None
+
+    if not isinstance(seqlens_Q, Tensor) or not isinstance(seqlens_KV, Tensor):
+        raise ValueError("seqlens_Q and seqlens_KV must both be tensors.")
+
+    if seqlens_Q.device != query.device or seqlens_KV.device != query.device:
+        raise ValueError(
+            "seqlens_Q and seqlens_KV must be on the same device as QKV, but "
+            f"{seqlens_Q.device=}, {seqlens_KV.device=}, {query.device=}."
+        )
+
+    if seqlens_Q.dtype != torch.int32 or seqlens_KV.dtype != torch.int32:
+        raise ValueError(
+            f"seqlens_Q and seqlens_KV must both be torch.int32 tensors, got {seqlens_Q.dtype=}, {seqlens_KV.dtype=}."
+        )
+
+    if seqlens_Q.dim() != 1 or seqlens_KV.dim() != 1:
+        raise ValueError(
+            f"seqlens_Q and seqlens_KV must both be 1-D tensors, got {seqlens_Q.dim()=}, {seqlens_KV.dim()=}."
+        )
+
+    if seqlens_Q.shape[0] != seqlens_KV.shape[0]:
+        raise ValueError(f"seqlens_Q and seqlens_KV must match in size, got {seqlens_Q.shape=}, {seqlens_KV.shape=}.")
+
+    if seqlens_Q.shape[0] < 1:
+        raise ValueError(
+            f"seqlens_Q and seqlens_KV must contain at least one element, got {seqlens_Q.shape=}, {seqlens_KV.shape=}."
+        )
+
+    if query.shape[0] != 1:
+        raise ValueError(
+            f"Variable length attention only supports sequence-packed memory layout (batch = 1), got {query.shape[0]=}."
+        )
+
+    assert seqlens_Q.dim() == seqlens_KV.dim() == 1
+    assert seqlens_Q.shape[0] == seqlens_KV.shape[0] >= 1
+    assert seqlens_Q.dtype == seqlens_KV.dtype == torch.int32
+
+    max_seqlen_Q = seqlens_Q.max().item()  # type: ignore
+    max_seqlen_KV = seqlens_KV.max().item()  # type: ignore
+
+    # NOTE: we have to prepend with 0 manually :(
+    z = torch.tensor([0], dtype=torch.int32, device=seqlens_Q.device)
+    cumulative_seqlen_Q = torch.cat([z, seqlens_Q.cumsum(0).to(torch.int32)], dim=0)
+    cumulative_seqlen_KV = torch.cat([z, seqlens_KV.cumsum(0).to(torch.int32)], dim=0)
+
+    assert isinstance(max_seqlen_Q, int)
+    assert isinstance(max_seqlen_KV, int)
+
+    return (
+        cumulative_seqlen_Q,
+        cumulative_seqlen_KV,
+        max_seqlen_Q,
+        max_seqlen_KV,
+    )

REGEN-main/cosmos_policy/_src/imaginaire/auxiliary/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

REGEN-main/cosmos_policy/_src/imaginaire/auxiliary/guardrail/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

REGEN-main/cosmos_policy/_src/imaginaire/auxiliary/guardrail/blocklist/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

REGEN-main/cosmos_policy/_src/imaginaire/auxiliary/guardrail/blocklist/blocklist.py

@@ -0,0 +1,248 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import os
+import re
+import string
+from difflib import SequenceMatcher
+
+import nltk
+from better_profanity import profanity
+
+from cosmos_policy._src.imaginaire.auxiliary.guardrail.blocklist.utils import read_keyword_list_from_dir, to_ascii
+from cosmos_policy._src.imaginaire.auxiliary.guardrail.common.core import (
+    GUARDRAIL1_CHECKPOINT_DIR,
+    ContentSafetyGuardrail,
+    GuardrailRunner,
+)
+from cosmos_policy._src.imaginaire.utils import log, misc
+
+CENSOR = misc.Color.red("*")
+
+
+class Blocklist(ContentSafetyGuardrail):
+    def __init__(
+        self,
+        guardrail_partial_match_min_chars: int = 6,
+        guardrail_partial_match_letter_count: float = 0.4,
+    ) -> None:
+        """Blocklist model for text filtering safety check.
+
+        Args:
+            checkpoint_dir (str): Path to the checkpoint directory.
+            guardrail_partial_match_min_chars (int, optional): Minimum number of characters in a word to check for partial match. Defaults to 6.
+            guardrail_partial_match_letter_count (float, optional): Maximum allowed difference in characters for partial match. Defaults to 0.4.
+        """
+        self.checkpoint_dir = os.path.join(GUARDRAIL1_CHECKPOINT_DIR, "blocklist")
+        nltk.data.path.append(os.path.join(self.checkpoint_dir, "nltk_data"))
+        self.lemmatizer = nltk.WordNetLemmatizer()
+        self.profanity = profanity
+        self.guardrail_partial_match_min_chars = guardrail_partial_match_min_chars
+        self.guardrail_partial_match_letter_count = guardrail_partial_match_letter_count
+
+        # Load blocklist and whitelist keywords
+        self.blocklist_words = read_keyword_list_from_dir(os.path.join(self.checkpoint_dir, "custom"))
+        self.whitelist_words = read_keyword_list_from_dir(os.path.join(self.checkpoint_dir, "whitelist"))
+        self.exact_match_words = read_keyword_list_from_dir(os.path.join(self.checkpoint_dir, "exact_match"))
+
+        self.profanity.load_censor_words(custom_words=self.blocklist_words, whitelist_words=self.whitelist_words)
+        log.debug(f"Loaded {len(self.blocklist_words)} words/phrases from blocklist")
+        log.debug(f"Whitelisted {len(self.whitelist_words)} words/phrases from whitelist")
+        log.debug(f"Loaded {len(self.exact_match_words)} exact match words/phrases from blocklist")
+
+    def uncensor_whitelist(self, input_prompt: str, censored_prompt: str) -> str:
+        """Explicitly uncensor words that are in the whitelist."""
+        input_words = input_prompt.split()
+        censored_words = censored_prompt.split()
+        whitelist_words = set(self.whitelist_words)
+        for i, token in enumerate(input_words):
+            if token.strip(string.punctuation).lower() in whitelist_words:
+                censored_words[i] = token
+        censored_prompt = " ".join(censored_words)
+        return censored_prompt
+
+    def censor_prompt(self, input_prompt: str) -> tuple[bool, str]:
+        """Censor the prompt using the blocklist with better-profanity fuzzy matching.
+
+        Args:
+            input_prompt: input prompt to censor
+
+        Returns:
+            bool: True if the prompt is blocked, False otherwise
+            str: A message indicating why the prompt was blocked
+        """
+        censored_prompt = self.profanity.censor(input_prompt, censor_char=CENSOR)
+        # Uncensor whitelisted words that were censored from blocklist fuzzy matching
+        censored_prompt = self.uncensor_whitelist(input_prompt, censored_prompt)
+        if CENSOR in censored_prompt:
+            return True, f"Prompt blocked by censorship: Censored Prompt: {censored_prompt}"
+        return False, ""
+
+    @staticmethod
+    def check_partial_match(
+        normalized_prompt: str, normalized_word: str, guardrail_partial_match_letter_count: float
+    ) -> tuple[bool, str]:
+        """
+        Check robustly if normalized word and the matching target have a difference of up to guardrail_partial_match_letter_count characters.
+
+        Args:
+            normalized_prompt: a string with many words
+            normalized_word: a string with one or multiple words, its length is smaller than normalized_prompt
+            guardrail_partial_match_letter_count: maximum allowed difference in characters (float to allow partial characters)
+
+        Returns:
+            bool: True if a match is found, False otherwise
+            str: A message indicating why the prompt was blocked
+        """
+        prompt_words = normalized_prompt.split()
+        word_length = len(normalized_word.split())
+        max_similarity_ratio = (len(normalized_word) - float(guardrail_partial_match_letter_count)) / float(
+            len(normalized_word)
+        )
+
+        seq_matcher = SequenceMatcher(None)
+        seq_matcher.set_seq2(normalized_word)
+
+        for i in range(len(prompt_words) - word_length + 1):
+            # Extract a substring from the prompt with the same number of words as the normalized_word
+            substring = " ".join(prompt_words[i : i + word_length])
+            seq_matcher.set_seq1(substring)
+
+            # real_quick_ratio and quick_ratio are faster than ratio and both serve as upper bound for similarity ratio.
+            # If they are less than max_similarity_ratio, it means that also the ratio will be less than max_similarity_ratio and we can skip the expensive ratio computation.
+            # This saves a lot of time because in practice the tested words are usually dissimilar.
+            # For details see: https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher
+            if (
+                seq_matcher.real_quick_ratio() < max_similarity_ratio
+                or seq_matcher.quick_ratio() < max_similarity_ratio
+            ):
+                continue
+
+            similarity_ratio = seq_matcher.ratio()
+            if similarity_ratio >= max_similarity_ratio:
+                return (
+                    True,
+                    f"Prompt blocked by partial match blocklist: Prompt: {normalized_prompt}, Partial Match Word: {normalized_word}",
+                )
+
+        return False, ""
+
+    @staticmethod
+    def check_against_whole_word_blocklist(
+        prompt: str,
+        blocklist: list[str],
+        guardrail_partial_match_min_chars: int = 6,
+        guardrail_partial_match_letter_count: float = 0.4,
+    ) -> tuple[bool, str]:
+        """
+        Check if the prompt contains any whole words from the blocklist.
+        The match is case insensitive and robust to multiple spaces between words.
+
+        Args:
+            prompt: input prompt to check
+            blocklist: list of words to check against
+            guardrail_partial_match_min_chars: minimum number of characters in a word to check for partial match
+            guardrail_partial_match_letter_count: maximum allowed difference in characters for partial match
+
+        Returns:
+            tuple[bool, str]: (True if a match is found, False otherwise), message indicating why the prompt was blocked
+        """
+        # Normalize spaces and convert to lowercase
+        normalized_prompt = re.sub(r"\s+", " ", prompt).strip().lower()
+
+        normalized_words_cache = set()
+
+        for word in blocklist:
+            # Normalize spaces and convert to lowercase for each blocklist word
+            normalized_word = re.sub(r"\s+", " ", word).strip().lower()
+
+            if normalized_word in normalized_words_cache:
+                continue
+
+            normalized_words_cache.add(normalized_word)
+
+            # Use word boundaries to ensure whole word match
+            if re.search(r"\b" + re.escape(normalized_word) + r"\b", normalized_prompt):
+                return True, f"Prompt blocked by exact match blocklist: Prompt: {prompt}, Exact Match Word: {word}"
+
+        # Roughly 3/4 of the time this function requires is spent on partial matching.
+        # We could use just one for loop to check both exact and partial matches but doing it in two loops is faster in practice
+        # because it delays the partial matching as long as possible with a chance of early exit due to exact match.
+        # Above we cache the normalized words and here we reuse them in the second loop for partial matching.
+
+        for normalized_word in normalized_words_cache:
+            # Check for partial match if the word is long enough
+            if len(normalized_word) >= guardrail_partial_match_min_chars:
+                match, message = Blocklist.check_partial_match(
+                    normalized_prompt, normalized_word, guardrail_partial_match_letter_count
+                )
+                if match:
+                    return True, message
+
+        return False, ""
+
+    def is_safe(self, input_prompt: str = "") -> tuple[bool, str]:
+        """Check if the input prompt is safe using the blocklist."""
+        # Check if the input is empty
+        if not input_prompt:
+            return False, "Input is empty"
+        input_prompt = to_ascii(input_prompt)
+
+        # Check full sentence for censored words
+        censored, message = self.censor_prompt(input_prompt)
+        if censored:
+            return False, message
+
+        # Check lemmatized words for censored words
+        tokens = nltk.word_tokenize(input_prompt)
+        lemmas = [self.lemmatizer.lemmatize(token) for token in tokens]
+        lemmatized_prompt = " ".join(lemmas)
+        censored, message = self.censor_prompt(lemmatized_prompt)
+        if censored:
+            return False, message
+
+        # Check for exact match blocklist words
+        censored, message = self.check_against_whole_word_blocklist(
+            input_prompt,
+            self.exact_match_words,
+            self.guardrail_partial_match_min_chars,
+            self.guardrail_partial_match_letter_count,
+        )
+        if censored:
+            return False, message
+
+        # If all these checks pass, the input is safe
+        return True, "Input is safe"
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--prompt", type=str, required=True, help="Input prompt")
+    return parser.parse_args()
+
+
+def main(args):
+    blocklist = Blocklist()
+    runner = GuardrailRunner(safety_models=[blocklist])
+    with misc.timer("blocklist safety check"):
+        safety, message = runner.run_safety_check(args.prompt)
+    log.info(f"Input is: {'SAFE' if safety else 'UNSAFE'}")
+    log.info(f"Message: {message}") if not safety else None
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)

REGEN-main/cosmos_policy/_src/imaginaire/auxiliary/guardrail/blocklist/blocklist_test.py

@@ -0,0 +1,57 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+from cosmos_policy._src.imaginaire.auxiliary.guardrail.blocklist.blocklist import Blocklist
+
+
+@pytest.mark.L1
+def test_exact_match():
+    """Test exact word matching."""
+    prompt = "this contains badword in the middle"
+    word = "badword"
+
+    match, message = Blocklist.check_partial_match(prompt, word, 0.4)
+
+    assert match is True
+    assert "badword" in message
+
+
+@pytest.mark.L1
+def test_no_match():
+    """Test when there's no match."""
+    prompt = "this is a clean prompt"
+    word = "badword"
+
+    match, message = Blocklist.check_partial_match(prompt, word, 0.4)
+
+    assert match is False
+    assert message == ""
+
+
+@pytest.mark.L1
+def test_partial_match_with_threshold():
+    """Test partial matching with character difference threshold."""
+    prompt = "this contains badw0rd here"  # One character different
+    word = "badword"
+
+    # With threshold of 1.0 character difference, should match
+    match, _ = Blocklist.check_partial_match(prompt, word, 1.0)
+    assert match is True
+
+    # With threshold of 0.5 character difference, should not match
+    match, _ = Blocklist.check_partial_match(prompt, word, 0.5)
+    assert match is False

REGEN-main/cosmos_policy/_src/imaginaire/auxiliary/guardrail/blocklist/profile_blocklist.py

@@ -0,0 +1,59 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import time
+
+from cosmos_policy._src.imaginaire.auxiliary.guardrail.blocklist.blocklist import Blocklist
+from cosmos_policy._src.imaginaire.auxiliary.guardrail.common.core import GuardrailRunner
+
+# Test prompts
+prompts = [
+    "Create a beautiful landscape",
+    "Generate a detailed cinematic scene of a bustling medieval marketplace with merchants selling colorful spices, fabrics hanging from wooden stalls, cobblestone streets filled with people in period clothing, warm golden hour lighting filtering through ancient stone buildings, and smoke rising from food vendors cooking over open fires",
+    "Create an image of Adele",
+    "lot of words" * 100 + "Create an image of Adele",
+    "lot of words" * 100 + "Create an image of Adeele",
+    "Make an image of someone getting hurt badly",
+    "Generate a disturbing scene with graphic violence showing people fighting brutally with weapons, blood splattered everywhere, gruesome injuries visible in high detail, screaming faces contorted in pain and terror, dark atmosphere with dramatic lighting emphasizing the carnage and destruction, bodies lying motionless on the ground surrounded by pools of crimson liquid",
+    "Show me a peaceful garden with flowers blooming in spring sunlight",
+    "Design a futuristic space station orbiting Earth with advanced technology, sleek metallic surfaces reflecting starlight, astronauts in cutting-edge spacesuits conducting research, multiple docking bays with various spacecraft, solar panels gleaming in the cosmic void, and Earth's blue marble visible in the background through massive observation windows",
+]
+
+checkpoint_dir = "/path/to/your/checkpoint/dir"  # Change this path
+
+# Initialize
+blocklist = Blocklist(checkpoint_dir=checkpoint_dir)
+runner = GuardrailRunner(safety_models=[blocklist])
+
+# Warm up
+_ = runner.run_safety_check(prompts[0])
+
+
+times = []
+for prompt in prompts:
+    start = time.time()
+    safe, message = runner.run_safety_check(prompt)
+    end = time.time()
+
+    elapsed = end - start
+    times.append(elapsed)
+
+    print(f"Prompt: '{prompt[:50]}...'")
+    print(f"Safe: {safe}, Time: {elapsed:.4f}s")
+    if message:
+        print(f"Message: {message}")
+    print("-" * 40)
+
+print(f"\nAverage time: {sum(times) / len(times):.4f}s")

REGEN-main/cosmos_policy/_src/imaginaire/auxiliary/guardrail/blocklist/utils.py

@@ -0,0 +1,45 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import re
+
+from cosmos_policy._src.imaginaire.utils import log
+
+
+def read_keyword_list_from_dir(folder_path: str) -> list[str]:
+    """Read keyword list from all files in a folder."""
+    output_list = []
+    file_list = []
+    # Get list of files in the folder
+    for file in os.listdir(folder_path):
+        if os.path.isfile(os.path.join(folder_path, file)):
+            file_list.append(file)
+
+    # Process each file
+    for file in file_list:
+        file_path = os.path.join(folder_path, file)
+        try:
+            with open(file_path) as f:
+                output_list.extend([line.strip() for line in f.readlines()])
+        except Exception as e:
+            log.error(f"Error reading file {file}: {e!s}")
+
+    return output_list
+
+
+def to_ascii(prompt: str) -> str:
+    """Convert prompt to ASCII."""
+    return re.sub(r"[^\x00-\x7F]+", " ", prompt)

REGEN-main/cosmos_policy/_src/imaginaire/auxiliary/guardrail/common/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.