pr-include-rev-in-flake

.gitattributes

@@ -1,4 +1 @@
 *.so filter=lfs diff=lfs merge=lfs -text
-build/torch210-cu128-x86_64-windows/_deformable_detr_cuda_d8a6191.pyd filter=lfs diff=lfs merge=lfs -text
-build/torch211-cu128-x86_64-windows/_deformable_detr_cuda_ff2cd18.pyd filter=lfs diff=lfs merge=lfs -text
-build/torch211-cu128-x86_64-windows/_deformable_detr_cuda_a4c5c25.pyd filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,26 +1,6 @@
 ---
-library_name: kernels
 license: apache-2.0
+tags:
+  - kernel
 ---
 
-This is the repository card of kernels-community/deformable-detr that has been pushed on the Hub. It was built to be used with the [`kernels` library](https://github.com/huggingface/kernels). This card was automatically generated.
-
-## How to use
-
-```python
-# make sure `kernels` is installed: `pip install -U kernels`
-from kernels import get_kernel
-
-kernel_module = get_kernel("kernels-community/deformable-detr")
-ms_deform_attn_forward = kernel_module.ms_deform_attn_forward
-
-ms_deform_attn_forward(...)
-```
-
-## Available functions
-- `ms_deform_attn_forward`
-- `ms_deform_attn_backward`
-
-## Benchmarks
-
-Benchmarking script is available for this kernel. Run `kernels benchmark kernels-community/deformable-detr`.

benchmarks/benchmark.py

@@ -1,250 +0,0 @@
-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.toml

@@ -0,0 +1,19 @@
+[general]
+name = "deformable_detr"
+
+[torch]
+src = [
+  "torch-ext/torch_binding.cpp",
+  "torch-ext/torch_binding.h"
+]
+
+[kernel.activation]
+cuda-capabilities = [ "7.0", "7.2", "7.5", "8.0", "8.6", "8.7", "8.9", "9.0" ]
+src = [
+  "deformable_detr/ms_deform_attn_cuda.cu",
+  "deformable_detr/ms_deform_im2col_cuda.cuh",
+  "deformable_detr/ms_deform_attn_cuda.cuh",
+  "deformable_detr/ms_deform_attn_cuda.h",
+]
+include = ["."]
+depends = [ "torch" ]

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

@@ -1,46 +0,0 @@
-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/_ops.py

@@ -1,9 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,21 +0,0 @@
-{
-  "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/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _deformable_detr_cuda_5129df0
-ops = torch.ops._deformable_detr_cuda_5129df0
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_deformable_detr_cuda_5129df0::{op_name}"

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

@@ -1,26 +0,0 @@
-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/metadata.json

@@ -1,20 +0,0 @@
-{
-  "name": "deformable-detr",
-  "id": "_deformable_detr_cuda_5129df0",
-  "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

@@ -1,46 +0,0 @@
-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/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _deformable_detr_cuda_5129df0
-ops = torch.ops._deformable_detr_cuda_5129df0
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_deformable_detr_cuda_5129df0::{op_name}"

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

@@ -1,26 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,20 +0,0 @@
-{
-  "name": "deformable-detr",
-  "id": "_deformable_detr_cuda_5129df0",
-  "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

@@ -1,46 +0,0 @@
-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_5129df0.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7e47fb27665b884b9862ad0c7b172c518e858894ab76aa850b35456c2aaeefc7
-size 11621120

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

@@ -1,9 +0,0 @@
-import torch
-from . import _deformable_detr_cuda_5129df0
-ops = torch.ops._deformable_detr_cuda_5129df0
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_deformable_detr_cuda_5129df0::{op_name}"

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

@@ -1,26 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,23 +0,0 @@
-{
-  "name": "deformable-detr",
-  "id": "_deformable_detr_cuda_5129df0",
-  "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

@@ -1,46 +0,0 @@
-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_5129df0.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f6144f094d925d8d1f187bef56134f21353df4b62e5cf3ba9c6a60a059630400
-size 11524560

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

@@ -1,9 +0,0 @@
-import torch
-from . import _deformable_detr_cuda_5129df0
-ops = torch.ops._deformable_detr_cuda_5129df0
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_deformable_detr_cuda_5129df0::{op_name}"

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

@@ -1,26 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,23 +0,0 @@
-{
-  "name": "deformable-detr",
-  "id": "_deformable_detr_cuda_5129df0",
-  "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

@@ -1,46 +0,0 @@
-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/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _deformable_detr_cuda_5129df0
-ops = torch.ops._deformable_detr_cuda_5129df0
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_deformable_detr_cuda_5129df0::{op_name}"

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

@@ -1,26 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,21 +0,0 @@
-{
-  "name": "deformable-detr",
-  "id": "_deformable_detr_cuda_5129df0",
-  "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

@@ -1,46 +0,0 @@
-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_5129df0.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:dc924d4f8fa8b6375abed86185db3e07118fdc9387fde2faa6199c0af810476a
-size 9809000

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

@@ -1,9 +0,0 @@
-import torch
-from . import _deformable_detr_cuda_5129df0
-ops = torch.ops._deformable_detr_cuda_5129df0
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_deformable_detr_cuda_5129df0::{op_name}"

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

@@ -1,26 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,21 +0,0 @@
-{
-  "name": "deformable-detr",
-  "id": "_deformable_detr_cuda_5129df0",
-  "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-cu128-x86_64-windows/__init__.py

@@ -1,46 +0,0 @@
-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-cu128-x86_64-windows/_deformable_detr_cuda_a4c5c25.pyd

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6901592b0cde22932ed33bd9357fdbff9747d916c56fc25ffa455d7bb575bef5
-size 9546240

build/torch211-cu128-x86_64-windows/_ops.py

@@ -1,9 +0,0 @@
-import torch
-from . import _deformable_detr_cuda_a4c5c25
-ops = torch.ops._deformable_detr_cuda_a4c5c25
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_deformable_detr_cuda_a4c5c25::{op_name}"

build/torch211-cu128-x86_64-windows/deformable_detr/__init__.py

@@ -1,26 +0,0 @@
-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-cu128-x86_64-windows/layers.py

@@ -1,84 +0,0 @@
-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/torch211-cu128-x86_64-windows/metadata.json

@@ -1,21 +0,0 @@
-{
-  "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/torch211-cxx11-cu126-aarch64-linux/__init__.py

@@ -1,46 +0,0 @@
-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_5129df0.abi3.so

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cb34add17209b87b62eb02c5d67e67cc566779a48bfe31080fa48f59c3102052
-size 8606480

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

@@ -1,9 +0,0 @@
-import torch
-from . import _deformable_detr_cuda_5129df0
-ops = torch.ops._deformable_detr_cuda_5129df0
-
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_deformable_detr_cuda_5129df0::{op_name}"

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

@@ -1,26 +0,0 @@
-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")))