drbh commited on 18 days ago

Commit

8e5f9d7

unverified ·

0 Parent(s):

Migrated from kernels-community/deformable-detr

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

.gitattributes +2 -0
README.md +22 -0
benchmarks/benchmark.py +250 -0
build/torch210-cu128-x86_64-windows/__init__.py +46 -0
build/torch210-cu128-x86_64-windows/_deformable_detr_cuda_d8a6191.pyd +3 -0
build/torch210-cu128-x86_64-windows/_ops.py +9 -0
build/torch210-cu128-x86_64-windows/deformable_detr/__init__.py +26 -0
build/torch210-cu128-x86_64-windows/layers.py +84 -0
build/torch210-cu128-x86_64-windows/metadata.json +21 -0
build/torch210-cxx11-cu126-aarch64-linux/__init__.py +46 -0
build/torch210-cxx11-cu126-aarch64-linux/_deformable_detr_cuda_52e302f.abi3.so +3 -0
build/torch210-cxx11-cu126-aarch64-linux/_ops.py +9 -0
build/torch210-cxx11-cu126-aarch64-linux/deformable_detr/__init__.py +26 -0
build/torch210-cxx11-cu126-aarch64-linux/layers.py +84 -0
build/torch210-cxx11-cu126-aarch64-linux/metadata.json +18 -0
build/torch210-cxx11-cu126-x86_64-linux/__init__.py +46 -0
build/torch210-cxx11-cu126-x86_64-linux/_deformable_detr_cuda_52e302f.abi3.so +3 -0
build/torch210-cxx11-cu126-x86_64-linux/_ops.py +9 -0
build/torch210-cxx11-cu126-x86_64-linux/deformable_detr/__init__.py +26 -0
build/torch210-cxx11-cu126-x86_64-linux/layers.py +84 -0
build/torch210-cxx11-cu126-x86_64-linux/metadata.json +18 -0
build/torch210-cxx11-cu128-aarch64-linux/__init__.py +46 -0
build/torch210-cxx11-cu128-aarch64-linux/_deformable_detr_cuda_52e302f.abi3.so +3 -0
build/torch210-cxx11-cu128-aarch64-linux/_ops.py +9 -0
build/torch210-cxx11-cu128-aarch64-linux/deformable_detr/__init__.py +26 -0
build/torch210-cxx11-cu128-aarch64-linux/layers.py +84 -0
build/torch210-cxx11-cu128-aarch64-linux/metadata.json +21 -0
build/torch210-cxx11-cu128-x86_64-linux/__init__.py +46 -0
build/torch210-cxx11-cu128-x86_64-linux/_deformable_detr_cuda_52e302f.abi3.so +3 -0
build/torch210-cxx11-cu128-x86_64-linux/_ops.py +9 -0
build/torch210-cxx11-cu128-x86_64-linux/deformable_detr/__init__.py +26 -0
build/torch210-cxx11-cu128-x86_64-linux/layers.py +84 -0
build/torch210-cxx11-cu128-x86_64-linux/metadata.json +21 -0
build/torch210-cxx11-cu130-aarch64-linux/__init__.py +46 -0
build/torch210-cxx11-cu130-aarch64-linux/_deformable_detr_cuda_52e302f.abi3.so +3 -0
build/torch210-cxx11-cu130-aarch64-linux/_ops.py +9 -0
build/torch210-cxx11-cu130-aarch64-linux/deformable_detr/__init__.py +26 -0
build/torch210-cxx11-cu130-aarch64-linux/layers.py +84 -0
build/torch210-cxx11-cu130-aarch64-linux/metadata.json +19 -0
build/torch210-cxx11-cu130-x86_64-linux/__init__.py +46 -0
build/torch210-cxx11-cu130-x86_64-linux/_deformable_detr_cuda_52e302f.abi3.so +3 -0
build/torch210-cxx11-cu130-x86_64-linux/_ops.py +9 -0
build/torch210-cxx11-cu130-x86_64-linux/deformable_detr/__init__.py +26 -0
build/torch210-cxx11-cu130-x86_64-linux/layers.py +84 -0
build/torch210-cxx11-cu130-x86_64-linux/metadata.json +19 -0
build/torch211-cxx11-cu126-aarch64-linux/__init__.py +46 -0
build/torch211-cxx11-cu126-aarch64-linux/_deformable_detr_cuda_52e302f.abi3.so +3 -0
build/torch211-cxx11-cu126-aarch64-linux/_ops.py +9 -0
build/torch211-cxx11-cu126-aarch64-linux/deformable_detr/__init__.py +26 -0
build/torch211-cxx11-cu126-aarch64-linux/layers.py +84 -0

.gitattributes ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ *.so filter=lfs diff=lfs merge=lfs -text
2	+ build/torch210-cu128-x86_64-windows/_deformable_detr_cuda_d8a6191.pyd filter=lfs diff=lfs merge=lfs -text

README.md ADDED Viewed

	@@ -0,0 +1,22 @@

+---
+license: apache-2.0
+tags:
+  - kernels
+---
+![Status](https://hubwebhook.dholtz.com/shield?repo=kernels-community/deformable-detr)
+## deformable-detr
+Kernel source: https://github.com/huggingface/kernels-community/tree/main/deformable-detr
+### Performance
+<img class="dark:hidden border border-gray-200 dark:border-gray-700 rounded-lg" src="media/benches_light_animation.svg" />
+<img class="hidden dark:block border border-gray-200 dark:border-gray-700 rounded-lg" src="media/benches_dark_animation.svg" />
+<img class="dark:hidden border border-gray-200 dark:border-gray-700 rounded-lg" src="media/benches_light_latency.svg" />
+<img class="hidden dark:block border border-gray-200 dark:border-gray-700 rounded-lg" src="media/benches_dark_latency.svg" />
+<img class="dark:hidden border border-gray-200 dark:border-gray-700 rounded-lg" src="media/benches_light_throughput.svg" />
+<img class="hidden dark:block border border-gray-200 dark:border-gray-700 rounded-lg" src="media/benches_dark_throughput.svg" />

benchmarks/benchmark.py ADDED Viewed

	@@ -0,0 +1,250 @@

+import torch
+import torch.nn.functional as F
+from kernels.benchmark import Benchmark
+def ms_deform_attn_reference(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_locations: torch.Tensor,
+    attention_weights: torch.Tensor,
+) -> torch.Tensor:
+    batch, _, num_heads, channels = value.shape
+    _, num_query, _, num_levels, num_points, _ = sampling_locations.shape
+    # Split value by levels
+    value_list = []
+    for level_id in range(num_levels):
+        H, W = spatial_shapes[level_id]
+        start_idx = level_start_index[level_id]
+        end_idx = (
+            level_start_index[level_id + 1]
+            if level_id < num_levels - 1
+            else value.shape[1]
+        )
+        # (batch, H*W, num_heads, channels) -> (batch, num_heads, channels, H, W)
+        value_level = value[:, start_idx:end_idx, :, :].view(
+            batch, H, W, num_heads, channels
+        )
+        value_level = value_level.permute(0, 3, 4, 1, 2).contiguous()
+        value_list.append(value_level)
+    # Sample from each level
+    output = torch.zeros(
+        batch, num_query, num_heads, channels, device=value.device, dtype=value.dtype
+    )
+    for level_id in range(num_levels):
+        H, W = spatial_shapes[level_id]
+        value_level = value_list[level_id]  # (batch, num_heads, channels, H, W)
+        # Get sampling locations for this level: (batch, num_query, num_heads, num_points, 2)
+        sampling_loc_level = sampling_locations[:, :, :, level_id, :, :]
+        # Convert from [0, 1] to [-1, 1] for grid_sample
+        grid = (
+            2.0 * sampling_loc_level - 1.0
+        )  # (batch, num_query, num_heads, num_points, 2)
+        # Reshape for grid_sample: need (batch * num_heads, channels, H, W) and (batch * num_heads, num_query, num_points, 2)
+        value_level = value_level.view(batch * num_heads, channels, H.item(), W.item())
+        grid = grid.permute(
+            0, 2, 1, 3, 4
+        ).contiguous()  # (batch, num_heads, num_query, num_points, 2)
+        grid = grid.view(batch * num_heads, num_query, num_points, 2)
+        # Sample: output is (batch * num_heads, channels, num_query, num_points)
+        sampled = F.grid_sample(
+            value_level,
+            grid,
+            mode="bilinear",
+            padding_mode="zeros",
+            align_corners=False,
+        )
+        # Reshape back: (batch, num_heads, channels, num_query, num_points)
+        sampled = sampled.view(batch, num_heads, channels, num_query, num_points)
+        # -> (batch, num_query, num_heads, num_points, channels)
+        sampled = sampled.permute(0, 3, 1, 4, 2).contiguous()
+        # Get attention weights for this level: (batch, num_query, num_heads, num_points)
+        attn_level = attention_weights[:, :, :, level_id, :]
+        # Weighted sum over points: (batch, num_query, num_heads, channels)
+        output += (sampled * attn_level.unsqueeze(-1)).sum(dim=3)
+    # Reshape to (batch, num_query, num_heads * channels)
+    output = output.view(batch, num_query, num_heads * channels)
+    return output
+class MSDeformAttnBenchmark(Benchmark):
+    seed: int = 42
+    def setup(self):
+        batch = 2
+        num_heads = 8
+        channels = 32  # embed_dim = num_heads * channels = 256
+        num_levels = 4
+        num_query = 300
+        num_points = 4
+        im2col_step = 64
+        # Spatial shapes for 4 levels: 64x64, 32x32, 16x16, 8x8
+        spatial_shapes = torch.tensor(
+            [[64, 64], [32, 32], [16, 16], [8, 8]],
+            dtype=torch.int64,
+            device=self.device,
+        )
+        # Calculate spatial_size = sum of H*W for all levels
+        spatial_size = (64 * 64) + (32 * 32) + (16 * 16) + (8 * 8)  # 5440
+        # Level start indices
+        level_start_index = torch.tensor(
+            [0, 64 * 64, 64 * 64 + 32 * 32, 64 * 64 + 32 * 32 + 16 * 16],
+            dtype=torch.int64,
+            device=self.device,
+        )
+        self.value = torch.randn(
+            batch,
+            spatial_size,
+            num_heads,
+            channels,
+            device=self.device,
+            dtype=torch.float32,
+        )
+        self.spatial_shapes = spatial_shapes
+        self.level_start_index = level_start_index
+        self.sampling_loc = torch.rand(
+            batch,
+            num_query,
+            num_heads,
+            num_levels,
+            num_points,
+            2,
+            device=self.device,
+            dtype=torch.float32,
+        )
+        self.attn_weight = torch.rand(
+            batch,
+            num_query,
+            num_heads,
+            num_levels,
+            num_points,
+            device=self.device,
+            dtype=torch.float32,
+        )
+        # Normalize attention weights
+        self.attn_weight = self.attn_weight / self.attn_weight.sum(-1, keepdim=True)
+        self.im2col_step = im2col_step
+        self.out = torch.empty(
+            batch,
+            num_query,
+            num_heads * channels,
+            device=self.device,
+            dtype=torch.float32,
+        )
+    def benchmark_forward(self):
+        self.out = self.kernel.ms_deform_attn_forward(
+            self.value,
+            self.spatial_shapes,
+            self.level_start_index,
+            self.sampling_loc,
+            self.attn_weight,
+            self.im2col_step,
+        )
+    def verify_forward(self) -> torch.Tensor:
+        return ms_deform_attn_reference(
+            self.value,
+            self.spatial_shapes,
+            self.level_start_index,
+            self.sampling_loc,
+            self.attn_weight,
+        )
+    def setup_large(self):
+        batch = 8
+        num_heads = 8
+        channels = 32
+        num_levels = 4
+        num_query = 900
+        num_points = 4
+        im2col_step = 64
+        spatial_shapes = torch.tensor(
+            [[64, 64], [32, 32], [16, 16], [8, 8]],
+            dtype=torch.int64,
+            device=self.device,
+        )
+        spatial_size = (64 * 64) + (32 * 32) + (16 * 16) + (8 * 8)
+        level_start_index = torch.tensor(
+            [0, 64 * 64, 64 * 64 + 32 * 32, 64 * 64 + 32 * 32 + 16 * 16],
+            dtype=torch.int64,
+            device=self.device,
+        )
+        self.value = torch.randn(
+            batch,
+            spatial_size,
+            num_heads,
+            channels,
+            device=self.device,
+            dtype=torch.float32,
+        )
+        self.spatial_shapes = spatial_shapes
+        self.level_start_index = level_start_index
+        self.sampling_loc = torch.rand(
+            batch,
+            num_query,
+            num_heads,
+            num_levels,
+            num_points,
+            2,
+            device=self.device,
+            dtype=torch.float32,
+        )
+        self.attn_weight = torch.rand(
+            batch,
+            num_query,
+            num_heads,
+            num_levels,
+            num_points,
+            device=self.device,
+            dtype=torch.float32,
+        )
+        self.attn_weight = self.attn_weight / self.attn_weight.sum(-1, keepdim=True)
+        self.im2col_step = im2col_step
+        self.out = torch.empty(
+            batch,
+            num_query,
+            num_heads * channels,
+            device=self.device,
+            dtype=torch.float32,
+        )
+    def benchmark_large(self):
+        self.out = self.kernel.ms_deform_attn_forward(
+            self.value,
+            self.spatial_shapes,
+            self.level_start_index,
+            self.sampling_loc,
+            self.attn_weight,
+            self.im2col_step,
+        )
+    def verify_large(self) -> torch.Tensor:
+        return ms_deform_attn_reference(
+            self.value,
+            self.spatial_shapes,
+            self.level_start_index,
+            self.sampling_loc,
+            self.attn_weight,
+        )

build/torch210-cu128-x86_64-windows/__init__.py ADDED Viewed

	@@ -0,0 +1,46 @@

+from typing import List
+import torch
+from ._ops import ops
+from . import layers
+def ms_deform_attn_backward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    grad_output: torch.Tensor,
+    im2col_step: int,
+) -> List[torch.Tensor]:
+    return ops.ms_deform_attn_backward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        grad_output,
+        im2col_step,
+    )
+def ms_deform_attn_forward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    im2col_step: int,
+) -> torch.Tensor:
+    return ops.ms_deform_attn_forward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        im2col_step,
+    )
+__all__ = ["layers", "ms_deform_attn_forward", "ms_deform_attn_backward"]

build/torch210-cu128-x86_64-windows/_deformable_detr_cuda_d8a6191.pyd ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:f94825a148a77c630ae4f24f75f65e96dd6e3379653643aa2e81420ba61a9db3
+size 9546240

build/torch210-cu128-x86_64-windows/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _deformable_detr_cuda_d8a6191
+ops = torch.ops._deformable_detr_cuda_d8a6191
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_deformable_detr_cuda_d8a6191::{op_name}"

build/torch210-cu128-x86_64-windows/deformable_detr/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import sys
+import importlib
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch210-cu128-x86_64-windows/layers.py ADDED Viewed

	@@ -0,0 +1,84 @@

+from typing import List, Union, Tuple
+from torch import Tensor
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+import torch.nn as nn
+from ._ops import ops
+class MultiScaleDeformableAttentionFunction(Function):
+    @staticmethod
+    def forward(
+        context,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        context.im2col_step = im2col_step
+        output = ops.ms_deform_attn_forward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            context.im2col_step,
+        )
+        context.save_for_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        )
+        return output
+    @staticmethod
+    @once_differentiable
+    def backward(context, grad_output):
+        (
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        ) = context.saved_tensors
+        grad_value, grad_sampling_loc, grad_attn_weight = ops.ms_deform_attn_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            grad_output,
+            context.im2col_step,
+        )
+        return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None
+class MultiScaleDeformableAttention(nn.Module):
+    def forward(
+        self,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_spatial_shapes_list: List[Tuple],
+        level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        return MultiScaleDeformableAttentionFunction.apply(
+            value,
+            value_spatial_shapes,
+            level_start_index,
+            sampling_locations,
+            attention_weights,
+            im2col_step,
+        )
+__all__ = ["MultiScaleDeformableAttention"]

build/torch210-cu128-x86_64-windows/metadata.json ADDED Viewed

	@@ -0,0 +1,21 @@

+{
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "10.1",
+      "12.0+PTX",
+      "7.0",
+      "7.2",
+      "7.5",
+      "8.0",
+      "8.6",
+      "8.7",
+      "8.9",
+      "9.0"
+    ]
+  }
+}

build/torch210-cxx11-cu126-aarch64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,46 @@

+from typing import List
+import torch
+from ._ops import ops
+from . import layers
+def ms_deform_attn_backward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    grad_output: torch.Tensor,
+    im2col_step: int,
+) -> List[torch.Tensor]:
+    return ops.ms_deform_attn_backward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        grad_output,
+        im2col_step,
+    )
+def ms_deform_attn_forward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    im2col_step: int,
+) -> torch.Tensor:
+    return ops.ms_deform_attn_forward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        im2col_step,
+    )
+__all__ = ["layers", "ms_deform_attn_forward", "ms_deform_attn_backward"]

build/torch210-cxx11-cu126-aarch64-linux/_deformable_detr_cuda_52e302f.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:521f9ff226174c047c6d384b8e39a92a427c06496ad87465c554c2b51239e317
+size 8606368

build/torch210-cxx11-cu126-aarch64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _deformable_detr_cuda_52e302f
+ops = torch.ops._deformable_detr_cuda_52e302f
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_deformable_detr_cuda_52e302f::{op_name}"

build/torch210-cxx11-cu126-aarch64-linux/deformable_detr/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch210-cxx11-cu126-aarch64-linux/layers.py ADDED Viewed

	@@ -0,0 +1,84 @@

+from typing import List, Union, Tuple
+from torch import Tensor
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+import torch.nn as nn
+from ._ops import ops
+class MultiScaleDeformableAttentionFunction(Function):
+    @staticmethod
+    def forward(
+        context,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        context.im2col_step = im2col_step
+        output = ops.ms_deform_attn_forward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            context.im2col_step,
+        )
+        context.save_for_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        )
+        return output
+    @staticmethod
+    @once_differentiable
+    def backward(context, grad_output):
+        (
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        ) = context.saved_tensors
+        grad_value, grad_sampling_loc, grad_attn_weight = ops.ms_deform_attn_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            grad_output,
+            context.im2col_step,
+        )
+        return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None
+class MultiScaleDeformableAttention(nn.Module):
+    def forward(
+        self,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_spatial_shapes_list: List[Tuple],
+        level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        return MultiScaleDeformableAttentionFunction.apply(
+            value,
+            value_spatial_shapes,
+            level_start_index,
+            sampling_locations,
+            attention_weights,
+            im2col_step,
+        )
+__all__ = ["MultiScaleDeformableAttention"]

build/torch210-cxx11-cu126-aarch64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,18 @@

+{
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "7.0",
+      "7.2",
+      "7.5",
+      "8.0",
+      "8.6",
+      "8.7",
+      "8.9",
+      "9.0+PTX"
+    ]
+  }
+}

build/torch210-cxx11-cu126-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,46 @@

+from typing import List
+import torch
+from ._ops import ops
+from . import layers
+def ms_deform_attn_backward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    grad_output: torch.Tensor,
+    im2col_step: int,
+) -> List[torch.Tensor]:
+    return ops.ms_deform_attn_backward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        grad_output,
+        im2col_step,
+    )
+def ms_deform_attn_forward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    im2col_step: int,
+) -> torch.Tensor:
+    return ops.ms_deform_attn_forward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        im2col_step,
+    )
+__all__ = ["layers", "ms_deform_attn_forward", "ms_deform_attn_backward"]

build/torch210-cxx11-cu126-x86_64-linux/_deformable_detr_cuda_52e302f.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:ddc6b5a40afe614d97965a4f35113df59852130e21699792bb883dcdd8b1228f
+size 8541080

build/torch210-cxx11-cu126-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _deformable_detr_cuda_52e302f
+ops = torch.ops._deformable_detr_cuda_52e302f
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_deformable_detr_cuda_52e302f::{op_name}"

build/torch210-cxx11-cu126-x86_64-linux/deformable_detr/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch210-cxx11-cu126-x86_64-linux/layers.py ADDED Viewed

	@@ -0,0 +1,84 @@

+from typing import List, Union, Tuple
+from torch import Tensor
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+import torch.nn as nn
+from ._ops import ops
+class MultiScaleDeformableAttentionFunction(Function):
+    @staticmethod
+    def forward(
+        context,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        context.im2col_step = im2col_step
+        output = ops.ms_deform_attn_forward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            context.im2col_step,
+        )
+        context.save_for_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        )
+        return output
+    @staticmethod
+    @once_differentiable
+    def backward(context, grad_output):
+        (
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        ) = context.saved_tensors
+        grad_value, grad_sampling_loc, grad_attn_weight = ops.ms_deform_attn_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            grad_output,
+            context.im2col_step,
+        )
+        return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None
+class MultiScaleDeformableAttention(nn.Module):
+    def forward(
+        self,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_spatial_shapes_list: List[Tuple],
+        level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        return MultiScaleDeformableAttentionFunction.apply(
+            value,
+            value_spatial_shapes,
+            level_start_index,
+            sampling_locations,
+            attention_weights,
+            im2col_step,
+        )
+__all__ = ["MultiScaleDeformableAttention"]

build/torch210-cxx11-cu126-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,18 @@

+{
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "7.0",
+      "7.2",
+      "7.5",
+      "8.0",
+      "8.6",
+      "8.7",
+      "8.9",
+      "9.0+PTX"
+    ]
+  }
+}

build/torch210-cxx11-cu128-aarch64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,46 @@

+from typing import List
+import torch
+from ._ops import ops
+from . import layers
+def ms_deform_attn_backward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    grad_output: torch.Tensor,
+    im2col_step: int,
+) -> List[torch.Tensor]:
+    return ops.ms_deform_attn_backward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        grad_output,
+        im2col_step,
+    )
+def ms_deform_attn_forward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    im2col_step: int,
+) -> torch.Tensor:
+    return ops.ms_deform_attn_forward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        im2col_step,
+    )
+__all__ = ["layers", "ms_deform_attn_forward", "ms_deform_attn_backward"]

build/torch210-cxx11-cu128-aarch64-linux/_deformable_detr_cuda_52e302f.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:6de7e1d1805eb6d51f7588654319610b0a8fb55755ab5b6f2f2c42792ba060a9
+size 11621120

build/torch210-cxx11-cu128-aarch64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _deformable_detr_cuda_52e302f
+ops = torch.ops._deformable_detr_cuda_52e302f
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_deformable_detr_cuda_52e302f::{op_name}"

build/torch210-cxx11-cu128-aarch64-linux/deformable_detr/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch210-cxx11-cu128-aarch64-linux/layers.py ADDED Viewed

	@@ -0,0 +1,84 @@

+from typing import List, Union, Tuple
+from torch import Tensor
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+import torch.nn as nn
+from ._ops import ops
+class MultiScaleDeformableAttentionFunction(Function):
+    @staticmethod
+    def forward(
+        context,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        context.im2col_step = im2col_step
+        output = ops.ms_deform_attn_forward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            context.im2col_step,
+        )
+        context.save_for_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        )
+        return output
+    @staticmethod
+    @once_differentiable
+    def backward(context, grad_output):
+        (
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        ) = context.saved_tensors
+        grad_value, grad_sampling_loc, grad_attn_weight = ops.ms_deform_attn_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            grad_output,
+            context.im2col_step,
+        )
+        return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None
+class MultiScaleDeformableAttention(nn.Module):
+    def forward(
+        self,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_spatial_shapes_list: List[Tuple],
+        level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        return MultiScaleDeformableAttentionFunction.apply(
+            value,
+            value_spatial_shapes,
+            level_start_index,
+            sampling_locations,
+            attention_weights,
+            im2col_step,
+        )
+__all__ = ["MultiScaleDeformableAttention"]

build/torch210-cxx11-cu128-aarch64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,21 @@

+{
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "10.1",
+      "12.0+PTX",
+      "7.0",
+      "7.2",
+      "7.5",
+      "8.0",
+      "8.6",
+      "8.7",
+      "8.9",
+      "9.0"
+    ]
+  }
+}

build/torch210-cxx11-cu128-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,46 @@

+from typing import List
+import torch
+from ._ops import ops
+from . import layers
+def ms_deform_attn_backward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    grad_output: torch.Tensor,
+    im2col_step: int,
+) -> List[torch.Tensor]:
+    return ops.ms_deform_attn_backward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        grad_output,
+        im2col_step,
+    )
+def ms_deform_attn_forward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    im2col_step: int,
+) -> torch.Tensor:
+    return ops.ms_deform_attn_forward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        im2col_step,
+    )
+__all__ = ["layers", "ms_deform_attn_forward", "ms_deform_attn_backward"]

build/torch210-cxx11-cu128-x86_64-linux/_deformable_detr_cuda_52e302f.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:c23af683cd86bb8f8a4426617c869403ea4fdba88b78935c676705e227523716
+size 11524560

build/torch210-cxx11-cu128-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _deformable_detr_cuda_52e302f
+ops = torch.ops._deformable_detr_cuda_52e302f
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_deformable_detr_cuda_52e302f::{op_name}"

build/torch210-cxx11-cu128-x86_64-linux/deformable_detr/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch210-cxx11-cu128-x86_64-linux/layers.py ADDED Viewed

	@@ -0,0 +1,84 @@

+from typing import List, Union, Tuple
+from torch import Tensor
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+import torch.nn as nn
+from ._ops import ops
+class MultiScaleDeformableAttentionFunction(Function):
+    @staticmethod
+    def forward(
+        context,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        context.im2col_step = im2col_step
+        output = ops.ms_deform_attn_forward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            context.im2col_step,
+        )
+        context.save_for_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        )
+        return output
+    @staticmethod
+    @once_differentiable
+    def backward(context, grad_output):
+        (
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        ) = context.saved_tensors
+        grad_value, grad_sampling_loc, grad_attn_weight = ops.ms_deform_attn_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            grad_output,
+            context.im2col_step,
+        )
+        return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None
+class MultiScaleDeformableAttention(nn.Module):
+    def forward(
+        self,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_spatial_shapes_list: List[Tuple],
+        level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        return MultiScaleDeformableAttentionFunction.apply(
+            value,
+            value_spatial_shapes,
+            level_start_index,
+            sampling_locations,
+            attention_weights,
+            im2col_step,
+        )
+__all__ = ["MultiScaleDeformableAttention"]

build/torch210-cxx11-cu128-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,21 @@

+{
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "10.1",
+      "12.0+PTX",
+      "7.0",
+      "7.2",
+      "7.5",
+      "8.0",
+      "8.6",
+      "8.7",
+      "8.9",
+      "9.0"
+    ]
+  }
+}

build/torch210-cxx11-cu130-aarch64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,46 @@

+from typing import List
+import torch
+from ._ops import ops
+from . import layers
+def ms_deform_attn_backward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    grad_output: torch.Tensor,
+    im2col_step: int,
+) -> List[torch.Tensor]:
+    return ops.ms_deform_attn_backward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        grad_output,
+        im2col_step,
+    )
+def ms_deform_attn_forward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    im2col_step: int,
+) -> torch.Tensor:
+    return ops.ms_deform_attn_forward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        im2col_step,
+    )
+__all__ = ["layers", "ms_deform_attn_forward", "ms_deform_attn_backward"]

build/torch210-cxx11-cu130-aarch64-linux/_deformable_detr_cuda_52e302f.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:e8bd9d5c6f5fdc673181ca67ec66a6f16d9c77a13fef13628b197aaa6d0ed98f
+size 9890792

build/torch210-cxx11-cu130-aarch64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _deformable_detr_cuda_52e302f
+ops = torch.ops._deformable_detr_cuda_52e302f
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_deformable_detr_cuda_52e302f::{op_name}"

build/torch210-cxx11-cu130-aarch64-linux/deformable_detr/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch210-cxx11-cu130-aarch64-linux/layers.py ADDED Viewed

	@@ -0,0 +1,84 @@

+from typing import List, Union, Tuple
+from torch import Tensor
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+import torch.nn as nn
+from ._ops import ops
+class MultiScaleDeformableAttentionFunction(Function):
+    @staticmethod
+    def forward(
+        context,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        context.im2col_step = im2col_step
+        output = ops.ms_deform_attn_forward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            context.im2col_step,
+        )
+        context.save_for_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        )
+        return output
+    @staticmethod
+    @once_differentiable
+    def backward(context, grad_output):
+        (
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        ) = context.saved_tensors
+        grad_value, grad_sampling_loc, grad_attn_weight = ops.ms_deform_attn_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            grad_output,
+            context.im2col_step,
+        )
+        return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None
+class MultiScaleDeformableAttention(nn.Module):
+    def forward(
+        self,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_spatial_shapes_list: List[Tuple],
+        level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        return MultiScaleDeformableAttentionFunction.apply(
+            value,
+            value_spatial_shapes,
+            level_start_index,
+            sampling_locations,
+            attention_weights,
+            im2col_step,
+        )
+__all__ = ["MultiScaleDeformableAttention"]

build/torch210-cxx11-cu130-aarch64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,19 @@

+{
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "11.0",
+      "12.0+PTX",
+      "7.5",
+      "8.0",
+      "8.6",
+      "8.7",
+      "8.9",
+      "9.0"
+    ]
+  }
+}

build/torch210-cxx11-cu130-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,46 @@

+from typing import List
+import torch
+from ._ops import ops
+from . import layers
+def ms_deform_attn_backward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    grad_output: torch.Tensor,
+    im2col_step: int,
+) -> List[torch.Tensor]:
+    return ops.ms_deform_attn_backward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        grad_output,
+        im2col_step,
+    )
+def ms_deform_attn_forward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    im2col_step: int,
+) -> torch.Tensor:
+    return ops.ms_deform_attn_forward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        im2col_step,
+    )
+__all__ = ["layers", "ms_deform_attn_forward", "ms_deform_attn_backward"]

build/torch210-cxx11-cu130-x86_64-linux/_deformable_detr_cuda_52e302f.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:7c26502008f0002400df7ed708d8014210ad43655701340ce9089bc342bf9e4b
+size 9808368

build/torch210-cxx11-cu130-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _deformable_detr_cuda_52e302f
+ops = torch.ops._deformable_detr_cuda_52e302f
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_deformable_detr_cuda_52e302f::{op_name}"

build/torch210-cxx11-cu130-x86_64-linux/deformable_detr/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch210-cxx11-cu130-x86_64-linux/layers.py ADDED Viewed

	@@ -0,0 +1,84 @@

+from typing import List, Union, Tuple
+from torch import Tensor
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+import torch.nn as nn
+from ._ops import ops
+class MultiScaleDeformableAttentionFunction(Function):
+    @staticmethod
+    def forward(
+        context,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        context.im2col_step = im2col_step
+        output = ops.ms_deform_attn_forward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            context.im2col_step,
+        )
+        context.save_for_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        )
+        return output
+    @staticmethod
+    @once_differentiable
+    def backward(context, grad_output):
+        (
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        ) = context.saved_tensors
+        grad_value, grad_sampling_loc, grad_attn_weight = ops.ms_deform_attn_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            grad_output,
+            context.im2col_step,
+        )
+        return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None
+class MultiScaleDeformableAttention(nn.Module):
+    def forward(
+        self,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_spatial_shapes_list: List[Tuple],
+        level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        return MultiScaleDeformableAttentionFunction.apply(
+            value,
+            value_spatial_shapes,
+            level_start_index,
+            sampling_locations,
+            attention_weights,
+            im2col_step,
+        )
+__all__ = ["MultiScaleDeformableAttention"]

build/torch210-cxx11-cu130-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,19 @@

+{
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "11.0",
+      "12.0+PTX",
+      "7.5",
+      "8.0",
+      "8.6",
+      "8.7",
+      "8.9",
+      "9.0"
+    ]
+  }
+}

build/torch211-cxx11-cu126-aarch64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,46 @@

+from typing import List
+import torch
+from ._ops import ops
+from . import layers
+def ms_deform_attn_backward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    grad_output: torch.Tensor,
+    im2col_step: int,
+) -> List[torch.Tensor]:
+    return ops.ms_deform_attn_backward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        grad_output,
+        im2col_step,
+    )
+def ms_deform_attn_forward(
+    value: torch.Tensor,
+    spatial_shapes: torch.Tensor,
+    level_start_index: torch.Tensor,
+    sampling_loc: torch.Tensor,
+    attn_weight: torch.Tensor,
+    im2col_step: int,
+) -> torch.Tensor:
+    return ops.ms_deform_attn_forward(
+        value,
+        spatial_shapes,
+        level_start_index,
+        sampling_loc,
+        attn_weight,
+        im2col_step,
+    )
+__all__ = ["layers", "ms_deform_attn_forward", "ms_deform_attn_backward"]

build/torch211-cxx11-cu126-aarch64-linux/_deformable_detr_cuda_52e302f.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:422cd51f413bc85e60b606ab8ead8850331a3b5e288d8a0e4923b10a68c0f4e5
+size 8606480

build/torch211-cxx11-cu126-aarch64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _deformable_detr_cuda_52e302f
+ops = torch.ops._deformable_detr_cuda_52e302f
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_deformable_detr_cuda_52e302f::{op_name}"

build/torch211-cxx11-cu126-aarch64-linux/deformable_detr/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch211-cxx11-cu126-aarch64-linux/layers.py ADDED Viewed

	@@ -0,0 +1,84 @@

+from typing import List, Union, Tuple
+from torch import Tensor
+from torch.autograd import Function
+from torch.autograd.function import once_differentiable
+import torch.nn as nn
+from ._ops import ops
+class MultiScaleDeformableAttentionFunction(Function):
+    @staticmethod
+    def forward(
+        context,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        context.im2col_step = im2col_step
+        output = ops.ms_deform_attn_forward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            context.im2col_step,
+        )
+        context.save_for_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        )
+        return output
+    @staticmethod
+    @once_differentiable
+    def backward(context, grad_output):
+        (
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+        ) = context.saved_tensors
+        grad_value, grad_sampling_loc, grad_attn_weight = ops.ms_deform_attn_backward(
+            value,
+            value_spatial_shapes,
+            value_level_start_index,
+            sampling_locations,
+            attention_weights,
+            grad_output,
+            context.im2col_step,
+        )
+        return grad_value, None, None, grad_sampling_loc, grad_attn_weight, None
+class MultiScaleDeformableAttention(nn.Module):
+    def forward(
+        self,
+        value: Tensor,
+        value_spatial_shapes: Tensor,
+        value_spatial_shapes_list: List[Tuple],
+        level_start_index: Tensor,
+        sampling_locations: Tensor,
+        attention_weights: Tensor,
+        im2col_step: int,
+    ):
+        return MultiScaleDeformableAttentionFunction.apply(
+            value,
+            value_spatial_shapes,
+            level_start_index,
+            sampling_locations,
+            attention_weights,
+            im2col_step,
+        )
+__all__ = ["MultiScaleDeformableAttention"]