Build

build/torch25-cxx11-cu118-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch25-cxx11-cu118-x86_64-linux/deformable_detr/_deformable_detr_cxy6p3o2latjs.abi3.so

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

build/torch25-cxx11-cu118-x86_64-linux/deformable_detr/_ops.py

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

build/torch25-cxx11-cu118-x86_64-linux/deformable_detr/layers.py

@@ -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/torch25-cxx11-cu121-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch25-cxx11-cu121-x86_64-linux/deformable_detr/_deformable_detr_esifsbuexbtbw.abi3.so

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

build/torch25-cxx11-cu121-x86_64-linux/deformable_detr/_ops.py

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

build/torch25-cxx11-cu121-x86_64-linux/deformable_detr/layers.py

@@ -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/torch25-cxx11-cu124-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch25-cxx11-cu124-x86_64-linux/deformable_detr/_deformable_detr_cuzn3o54ku5iq.abi3.so

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

build/torch25-cxx11-cu124-x86_64-linux/deformable_detr/_ops.py

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

build/torch25-cxx11-cu124-x86_64-linux/deformable_detr/layers.py

@@ -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/torch25-cxx98-cu118-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch25-cxx98-cu118-x86_64-linux/deformable_detr/_deformable_detr_gom2c5vfrl2ic.abi3.so

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

build/torch25-cxx98-cu118-x86_64-linux/deformable_detr/_ops.py

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

build/torch25-cxx98-cu118-x86_64-linux/deformable_detr/layers.py

@@ -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/torch25-cxx98-cu121-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch25-cxx98-cu121-x86_64-linux/deformable_detr/_deformable_detr_a7sajsuqrick6.abi3.so

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

build/torch25-cxx98-cu121-x86_64-linux/deformable_detr/_ops.py

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

build/torch25-cxx98-cu121-x86_64-linux/deformable_detr/layers.py

@@ -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/torch25-cxx98-cu124-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch25-cxx98-cu124-x86_64-linux/deformable_detr/_deformable_detr_tyogxwmtolvok.abi3.so

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

build/torch25-cxx98-cu124-x86_64-linux/deformable_detr/_ops.py

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

build/torch25-cxx98-cu124-x86_64-linux/deformable_detr/layers.py

@@ -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/torch26-cxx11-cu118-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch26-cxx11-cu118-x86_64-linux/deformable_detr/_deformable_detr_5kxpyt5yogkv2.abi3.so

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

build/torch26-cxx11-cu118-x86_64-linux/deformable_detr/_ops.py

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

build/torch26-cxx11-cu118-x86_64-linux/deformable_detr/layers.py

@@ -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/torch26-cxx11-cu124-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch26-cxx11-cu124-x86_64-linux/deformable_detr/_deformable_detr_titoehueyfqjg.abi3.so

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

build/torch26-cxx11-cu124-x86_64-linux/deformable_detr/_ops.py

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

build/torch26-cxx11-cu124-x86_64-linux/deformable_detr/layers.py

@@ -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/torch26-cxx11-cu126-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch26-cxx11-cu126-x86_64-linux/deformable_detr/_deformable_detr_imqt5tuqtmyt4.abi3.so

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

build/torch26-cxx11-cu126-x86_64-linux/deformable_detr/_ops.py

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

build/torch26-cxx11-cu126-x86_64-linux/deformable_detr/layers.py

@@ -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/torch26-cxx98-cu118-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch26-cxx98-cu118-x86_64-linux/deformable_detr/_deformable_detr_qbnaho3zp2d3o.abi3.so

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

build/torch26-cxx98-cu118-x86_64-linux/deformable_detr/_ops.py

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

build/torch26-cxx98-cu118-x86_64-linux/deformable_detr/layers.py

@@ -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/torch26-cxx98-cu124-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch26-cxx98-cu124-x86_64-linux/deformable_detr/_deformable_detr_5oxft6tr6jbvu.abi3.so

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

build/torch26-cxx98-cu124-x86_64-linux/deformable_detr/_ops.py

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

build/torch26-cxx98-cu124-x86_64-linux/deformable_detr/layers.py

@@ -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/torch26-cxx98-cu126-x86_64-linux/deformable_detr/__init__.py

@@ -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/torch26-cxx98-cu126-x86_64-linux/deformable_detr/_deformable_detr_po264mz2i2ffg.abi3.so

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

build/torch26-cxx98-cu126-x86_64-linux/deformable_detr/_ops.py

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

build/torch26-cxx98-cu126-x86_64-linux/deformable_detr/layers.py

@@ -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"]