diff --git a/build/torch210-cu126-aarch64-linux/__init__.py b/build/torch210-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/__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"] diff --git a/build/torch210-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch210-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..96fce2d3b32df16724d44a51000906f9a2b4be26 --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44601388b33d55f8b48b7c95f533b37454bac4f3eef7ee31268883830e30d677 +size 6661560 diff --git a/build/torch210-cu126-aarch64-linux/_ops.py b/build/torch210-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch210-cu126-aarch64-linux/layers.py b/build/torch210-cu126-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/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"] diff --git a/build/torch210-cu126-aarch64-linux/metadata.json b/build/torch210-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..04e55e1ef8d7fa49762d05a33eab9e70327f70e8 --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/metadata.json @@ -0,0 +1,43 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "RGATiLM9Vfi0i3yV9TOzdFS6xPPu9+4xJoiDgw4w1nc=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch210-cu126-aarch64-linux/metadata.json.sigstore b/build/torch210-cu126-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..76fd7a7bc8cc9995fcb5607b1ccc7517224c7743 --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115171","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407984","inclusionPromise":{"signedEntryTimestamp":"MEUCICulrd48bSIg5qhnT3iV6qN4EokKCilMQ+qrqK6F/kQrAiEAns0pP65DFYNV9dghhQfSuedNCY6WZ7ACoqdP4zDJols="},"inclusionProof":{"logIndex":"3198210909","rootHash":"FgQaySiiVVaEmKUp98P4PVyQ3jhSrP2RFLuGlHB/Se8=","treeSize":"3198210911","hashes":["eQYFfUN88UMkWt9SXVxJJcStaZhBM4Kd1/Eryv3woMQ=","CqUvhRx+73ms+t28YlPMmO6LESHY6SQTLDmYE/AkGGI=","bVVdXbvHzCmSqmYa3PmCokeBdJd3YtfNHCwFQHSimAw=","g1vCQIy+bVEOrPh1roH2gmMzhuWUGp4bqC7SC7QaJHU=","JYhlihMhsfv7dwe8hIIz+abL0YDJxome4Qs1/5XvH/U=","Opx4Trjms86Wh4oLCW6bQYl9YEjDZij7biMYuhm25+w=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198210911\nFgQaySiiVVaEmKUp98P4PVyQ3jhSrP2RFLuGlHB/Se8=\n\n— rekor.sigstore.dev wNI9ajBFAiEAw074cLJTvY0U+SPtRCGJyRoQPCxXLO5B+qYNO7TUE48CIAf4ddgudUjjWp9EXmBUP/RwrjC7WzvQ6gtpFA78ejpP\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgCEzu7/qnzSxnAXTI6RvMPWpuWDt98D8Ix7cVuvYrvZ0CFQDS3v/6ce5mIrgR+PVDd9CKfSWi8RgPMjAyNjEwMTkxMTA2MjRaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTExMDYyNFowLwYJKoZIhvcNAQkEMSIEIF/+dg6CO4ijqlF33Zl7HwNVSykxtsD5gUH9Y3fj+FdIMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMQD00Es1Rx0UJ1DwjBLaer6UMKMUWwMEdqneb3CP6/INjoh9soalBCtVrj6ANb4ZuEcCMBaz8ArzcIEY8/OLecvFOFdsfrfqPJyCBo2c2hjmUJc3y690x79wCO+2eK5RtJnqOg=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"9u3W5v3LElnFCdb0Qjng+47/u1C1sJfNYRFruvb4gVQ="},"signature":"MEQCIGia+61HTTmRXpoel/LWUgiOAhrs/s2VtHWFgRavWQ0bAiA1VxgbqJLAkZT1I0EOrbpFJhR8RIBpA0WtDJXS0gyKpA=="}} \ No newline at end of file diff --git a/build/torch210-cu126-aarch64-linux/symbols.json b/build/torch210-cu126-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch210-cu126-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch210-cu128-aarch64-linux/__init__.py b/build/torch210-cu128-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/__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"] diff --git a/build/torch210-cu128-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch210-cu128-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..75a8ec793b45fd5431ac695973553c79c5948a99 --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:922220e4936bc46ac0122b268dc6f69a3bba4253506ee07a170eef0407aa3e91 +size 9610648 diff --git a/build/torch210-cu128-aarch64-linux/_ops.py b/build/torch210-cu128-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch210-cu128-aarch64-linux/layers.py b/build/torch210-cu128-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/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"] diff --git a/build/torch210-cu128-aarch64-linux/metadata.json b/build/torch210-cu128-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..033ac1dfe5377380a80f6227f6e6a1a57c03407f --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-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" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "kiIg5JNrxGrAEismjcb2mju6QlNQbuB6Fw7vBAeqPpE=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch210-cu128-aarch64-linux/metadata.json.sigstore b/build/torch210-cu128-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..bd237135a114fd5e31cad7f52b1760acf55a85f5 --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115185","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407985","inclusionPromise":{"signedEntryTimestamp":"MEUCIQCi2LNZ69ol6R5mn4E/SFNNjWepKWFToH/i0O2h2hXbWwIgeKonjJrHSGBS7HDqLdRwSP0Ff+XARqo3yx4VVGOCeJo="},"inclusionProof":{"logIndex":"3198210923","rootHash":"NGWyj8VLbV/0Bhyk7g7cE67eEmMB8qJ3csfb02OpaaQ=","treeSize":"3198210925","hashes":["90YNjJdLX7bX2QE1NhZWiS181RrjNrGf7nr1z8HnGJA=","2T34hADKhmSQ6WMHJXLFXPuDfvfwa9yqHClD1EghgVY=","361nQE6dHJ+pam4qXLAJlboaWGLxf5b1f1gO4gJTw2E=","mWOrCjCW7gZ9Mvje80G1jtjsXjbmWmETsISnDZz8Gds=","P8NrC1C4XVtVLd2bOsaCbES1dbtLfQfSmf1t/w1SA3s=","Opx4Trjms86Wh4oLCW6bQYl9YEjDZij7biMYuhm25+w=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198210925\nNGWyj8VLbV/0Bhyk7g7cE67eEmMB8qJ3csfb02OpaaQ=\n\n— rekor.sigstore.dev wNI9ajBFAiEAz6AQQj6eDRjCU+je3gplsW2WGavi4fNo/GDBjDBlosoCIDSkxp1WoqcGJd/9rybEMNYVHMdD2NSSYVpYi2z8YgK7\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgQy1z1brS5vqMLUNGteAyVWNF3ZTQOxBE2oPlKxMz5k0CFBjv/Z0xQYIq6FXgq1mjOEexncizGA8yMDI2MTAxOTExMDYyNVowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTEwNjI1WjAvBgkqhkiG9w0BCQQxIgQgZF7uXpdSIAJ9hZlldyc7v2qeGRwdINtu0qqHZ6l4FL8wgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIxANXMPbUFM//1Vexm/pxgLbXFpMNBJ+/aFDNOrpKZnPkKTHUoi5vhQy1Lyb6Gh2NKfgIwHtfbvw7FR7rGoB2FsrytLuEMn4y6Xwc+iEY7rP87fPbB7/g86p0KPFWliDxjNwp/"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"NN/jmH9cMYH4hdNF14CJZJ7DpkO6Tw3DW78ynzW6XeU="},"signature":"MEYCIQDd2wdZk7SPJoxnKq+QS9dXnPLJ86rkJlVkbyjq7Kw0TAIhAPqZWvwPGZB3u991MoegZZ4ws3MgozjVD6SOhtwqVTDU"}} \ No newline at end of file diff --git a/build/torch210-cu128-aarch64-linux/symbols.json b/build/torch210-cu128-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch210-cu128-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch210-cu130-aarch64-linux/__init__.py b/build/torch210-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/__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"] diff --git a/build/torch210-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch210-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..49e9f6c35e227eacf7ce09aa5fdded93add8de2a --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:afe3c348831bd99e29054691a0cc6553260b5de61c1f741fcf2ee391a6918c7c +size 9846400 diff --git a/build/torch210-cu130-aarch64-linux/_ops.py b/build/torch210-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch210-cu130-aarch64-linux/layers.py b/build/torch210-cu130-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/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"] diff --git a/build/torch210-cu130-aarch64-linux/metadata.json b/build/torch210-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3ca97d035729afdad6f8f6cee22d55ca41a311cc --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "r+PDSIMb2Z4pBUaRoMxlUyYLXeYcH3Qfzy7jkaaRjHw=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch210-cu130-aarch64-linux/metadata.json.sigstore b/build/torch210-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..76c71a1cf569f27e686ebf6b021daff7be9174b9 --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115201","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407986","inclusionPromise":{"signedEntryTimestamp":"MEUCIHKHhuMJi4VQlYa0OObKTsDBG3M3QD67cbIM8uBgpCwwAiEAwtn47SlaKPNwb8S9jJf4AzW3+UgXYvP985iwtVSy0+8="},"inclusionProof":{"logIndex":"3198210939","rootHash":"QcEnty80LV0CQk8C30ksWFWYQaJVG4U/v61w7uNBVPM=","treeSize":"3198210944","hashes":["ygdQnX9Cd2aqSHBuwPW0IiUR7zAMuHA7fvaXzKDvTLU=","cNcf+E3DtoL4LNE31piEQNHrks3EwlLOoh6pY9XUn2Y=","tH/VtRZxOEJWLT11ro6CiP23V8YTDOi0v4BH0tm4prc=","o5N1wzFrCFfgacMnhOmxScIX22mpP98QZ9y/ODYKCXA=","EOZnA9VW23cpYBgiRfViAfKwBR410vCWTIS+A/CP0zo=","P8NrC1C4XVtVLd2bOsaCbES1dbtLfQfSmf1t/w1SA3s=","Opx4Trjms86Wh4oLCW6bQYl9YEjDZij7biMYuhm25+w=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198210944\nQcEnty80LV0CQk8C30ksWFWYQaJVG4U/v61w7uNBVPM=\n\n— rekor.sigstore.dev wNI9ajBFAiAn7zJXUl9kaMw8cOyOfNh3phD5vZ26DtxRS33m/PwOngIhAJtZU9+Z0WDuJPTVueXCFg3kE7KNpZovd2ZPeMsRTxmT\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQg4MsJYVN6N0jyBx66N+HXhSokRWggJbG8pbw4BGNK6mkCFQCxW3wNZKyRk7Qcud5wR58TeD8euRgPMjAyNjEwMTkxMTA2MjZaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTExMDYyNlowLwYJKoZIhvcNAQkEMSIEINtTnzbCNHs7P8TS06xJeQOBZzo1kN9DiZ0ShDBC/U5lMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMQC5jIwNoHiQkeVBNy96a/1YkQ3k36aCEKggY4R86LNhdb2GlgZOQ2SaH5UPLwi19+MCMAP9x9lgU6AhMOg9LDtaHSV3w5JzB8/NwX1B8CT7RnqrS6pi4iRIWpBVs7Tt04euUA=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"fj6OcttWJTqJJzzlp3XumqwsNx924nTdU1qvZ4r76kA="},"signature":"MEYCIQDJqKrFtwQaIwnh6NNLReP06wD/JK/fKyqnxn4LUNAT8AIhAMUAros3RvQCWj6G0GZjwwUdlT3rcR0oxwYFJqCghg9h"}} \ No newline at end of file diff --git a/build/torch210-cu130-aarch64-linux/symbols.json b/build/torch210-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch210-cu130-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch211-cu126-aarch64-linux/__init__.py b/build/torch211-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/__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"] diff --git a/build/torch211-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch211-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..10687fea66ffe51805fac57f1f09ce7bafc298a9 --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:18bff04b08a2cacd337075275093a54a208f1f02620fc032872edd94d9600830 +size 6661672 diff --git a/build/torch211-cu126-aarch64-linux/_ops.py b/build/torch211-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch211-cu126-aarch64-linux/layers.py b/build/torch211-cu126-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/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"] diff --git a/build/torch211-cu126-aarch64-linux/metadata.json b/build/torch211-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..fc2906b74776019386430fce282b8de0bb5156b5 --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/metadata.json @@ -0,0 +1,43 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "GL/wSwiiys0zcHUnUJOlSiCPHwJiD8Ayhy7dlNlgCDA=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch211-cu126-aarch64-linux/metadata.json.sigstore b/build/torch211-cu126-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..2dc178a570e282841faff1baab91fc195a2d212d --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115219","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407987","inclusionPromise":{"signedEntryTimestamp":"MEQCIAQv1oWkQ+Ja9ReyvQUbBtznGQBypNRMkDP09uGGFYsLAiB0wDuHiFEzmNcOf9r0TvgAa5furSGN8/UQKWI8sJnHvw=="},"inclusionProof":{"logIndex":"3198210957","rootHash":"WoGNEmCyDbxgLthLA5QX1y/szUgT3W9hUGE3fMkEx5s=","treeSize":"3198210959","hashes":["1aVP17SxN9Vc/txkIUGjt1urIzuJOsrxfhdzLUuNPgg=","2pwNGASwF1uycwFleaf2Gx0oaJerroqj5S0qQDphGYM=","lHhWsYHHqH/m9+ZsM856KE4ja+F+LJcVwAATv9tIVTc=","nZ/V6LhfcrYwUrMgPykTfcqvQon1xfSN2fhT8Ie4Wi4=","GuVvnGqaFV7gJ3r7URJzep/H3YozPXfaZGzcmRhfZ+8=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198210959\nWoGNEmCyDbxgLthLA5QX1y/szUgT3W9hUGE3fMkEx5s=\n\n— rekor.sigstore.dev wNI9ajBFAiEA3SnNO2P+sIEDzMUKEj8NSyUZjY/v1R3QwvH1fBs/QFMCIFBfs9+ueJ/oGqYdq2gXIUgplEU7PHaBP9bh/i6hQIO3\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQg7VFQ3CxXvlSs5vqXSRKNoVsriMgLtlcshWchA7ctbVMCFA+w1wAb5eh3JY0jdNAmVJbexpKhGA8yMDI2MTAxOTExMDYyN1owAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdwwggHYAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTEwNjI3WjAvBgkqhkiG9w0BCQQxIgQgE76qSbxZqQ6pFFQRM5uZW/0ndAaqykGzhtQY6KtBzbkwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGgwZgIxAK5NSU3ntQYaFcNV8qYiPW34UJBV+RgCPeP3xjLDKPAewugsWHjKojV3C2+mJUtPEwIxAOvwZy5tZ0k0GFpHYOmBUxezcYyEmXWXFFTKVbmpxidC5GcS0L4r4D/gqG4k5Q9w4Q=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"91becBuBvQi5xY+KYNhQM8SpFcFy/bc8p+S9Exaoto0="},"signature":"MEQCIBI4rjKTX14nFvmEyEQzcsbjlpZ4Go8NLF5HT5wTBAu1AiAeu+mtB/u0nQfMgFCi+4TrsXZlbimSGJZQyw+g7fhfZA=="}} \ No newline at end of file diff --git a/build/torch211-cu126-aarch64-linux/symbols.json b/build/torch211-cu126-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch211-cu126-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch211-cu128-aarch64-linux/__init__.py b/build/torch211-cu128-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/__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"] diff --git a/build/torch211-cu128-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch211-cu128-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..f90eeb56792c961c90384981d5e7454978b71fc8 --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9bcc9b35c9549366b29ca0e54770644a49535ff1892166b3362020f7236e2c9a +size 9610768 diff --git a/build/torch211-cu128-aarch64-linux/_ops.py b/build/torch211-cu128-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch211-cu128-aarch64-linux/layers.py b/build/torch211-cu128-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/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"] diff --git a/build/torch211-cu128-aarch64-linux/metadata.json b/build/torch211-cu128-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..756fb85119f7180c3c679d5e9332b7fd4379360f --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-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" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "m8ybNclUk2aynKDlR3BkSklTX/GJIWazNiAg9yNuLJo=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch211-cu128-aarch64-linux/metadata.json.sigstore b/build/torch211-cu128-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..e4dca863204141ab63fd25bc973aaa6bc735fca8 --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"MIIHLDCCBrKgAwIBAgIUcD5vS0m+lKTG/2TuUrYiIbCwjAUwCgYIKoZIzj0EAwMwNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRlcm1lZGlhdGUwHhcNMjYxMDE5MTEwNjI3WhcNMjYxMDE5MTExNjI3WjAAMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqZ0P1rsjnBEFIfPocOrDKuMy1etbzMYr8jjrrEZCC5V9GJ6GDotmob5OCwOy0+wZd442EnJ4vgtgb/axI9+KY6OCBdEwggXNMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAfBgNVHSMEGDAWgBTf0+nPViQRlvmo2OkoVaLGLhhkPzBrBgNVHREBAf8EYTBfhl1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOQYKKwYBBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50LmNvbTAfBgorBgEEAYO/MAECBBF3b3JrZmxvd19kaXNwYXRjaDA2BgorBgEEAYO/MAEDBChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBMGCisGAQQBg78wAQQEBUJ1aWxkMCsGCisGAQQBg78wAQUEHWh1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5MB0GCisGAQQBg78wAQYED3JlZnMvaGVhZHMvbWFpbjA7BgorBgEEAYO/MAEIBC0MK2h0dHBzOi8vdG9rZW4uYWN0aW9ucy5naXRodWJ1c2VyY29udGVudC5jb20wbQYKKwYBBAGDvzABCQRfDF1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOAYKKwYBBAGDvzABCgQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBsGCisGAQQBg78wAQsEDQwLc2VsZi1ob3N0ZWQwQAYKKwYBBAGDvzABDAQyDDBodHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkwOAYKKwYBBAGDvzABDQQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMB8GCisGAQQBg78wAQ4EEQwPcmVmcy9oZWFkcy9tYWluMBoGCisGAQQBg78wAQ8EDAwKMTA3MTQ3NTUyOTAuBgorBgEEAYO/MAEQBCAMHmh0dHBzOi8vZ2l0aHViLmNvbS9odWdnaW5nZmFjZTAYBgorBgEEAYO/MAERBAoMCDI1NzIwNzQzMG0GCisGAQQBg78wARIEXwxdaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5Ly5naXRodWIvd29ya2Zsb3dzL2J1aWxkLnlhbWxAcmVmcy9oZWFkcy9tYWluMDgGCisGAQQBg78wARMEKgwoZmUyYmI2NmZlZTZjMmE3N2VjY2YwOGEwNTA4ZGM1NzQyOGQ0ODhlZDAhBgorBgEEAYO/MAEUBBMMEXdvcmtmbG93X2Rpc3BhdGNoMGQGCisGAQQBg78wARUEVgxUaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5L2FjdGlvbnMvcnVucy8zOTIzOTUzNzc0Ni9hdHRlbXB0cy8xMBYGCisGAQQBg78wARYECAwGcHVibGljMEYGCisGAQQBg78wARgEOAw2cmVwbzpodWdnaW5nZmFjZS9rZXJuZWxzLWNvbW11bml0eTpyZWY6cmVmcy9oZWFkcy9tYWluMIGKBgorBgEEAdZ5AgQCBHwEegB4AHYA3T0wasbHETJjGR4cmWc3AqJKXrjePK3/h4pygC8p7o4AAAGhU9dm0gAABAMARzBFAiEAmeakUySGaCAB54pmx56+WqU483hLcbF8xjtkifnBvMgCIGNccMQ+3C5b0bd9TkFtdTOscwX0Fu3TRw3d5qsYGPKoMAoGCCqGSM49BAMDA2gAMGUCMCz4WN+POFEj30i17Ol/J1CFEu+Pa144DlChumtsqDxvDtbv5fYItONkekwoS+rJHQIxAMzvpAFdcVNVwtFLyZ4NWNmNYEt0X8zG711tPC020+cavWe52oxHcSLvFOGlopmoyQ=="},"tlogEntries":[{"logIndex":"3320115233","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407988","inclusionPromise":{"signedEntryTimestamp":"MEYCIQC8df4KomdcI6Ekb8538BfSj/2iGElvSYYTCpIUmvCQ5QIhAPTzkzKK0neapvRqr7e5fjhAfQG1xqZIeYkySXb+wbDX"},"inclusionProof":{"logIndex":"3198210971","rootHash":"ki8rVhfbC661nNuIIG66yebqjFREa2LD923mfT+lYF0=","treeSize":"3198210974","hashes":["4IpqtEMVQrC+A7BD+YYA8siRNnq5bxYlFiPolB4P9wQ=","dcpNyCMTXDq8c5zDbsICBljMTab/2COCAKuaoe4uH3s=","YzPe3LrHdMXIJn9tVmMdxNLsQ4RvJH+POJFlBafFLFU=","CQ2ubMX1MHj4ViMcmlj3qoQYpA5cQZB90wF6zIxbJjs=","eQL/ljuW1lZaa8UDkcqCkckv3oYhv60AhRt1ALMjbLI=","GuVvnGqaFV7gJ3r7URJzep/H3YozPXfaZGzcmRhfZ+8=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198210974\nki8rVhfbC661nNuIIG66yebqjFREa2LD923mfT+lYF0=\n\n— rekor.sigstore.dev wNI9ajBEAiBy6ENz+yYDhNWhbUKF1lxBxBnz5NMOzJxeO9RG7nzJxAIgMBOP1LL3qT082fdckyDWCYksahy2udub/UQ1ynm1ua4=\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgCq/d6CsALcdiRlfhxeGpByieQivRBiJ01xl5Ln5li6ECFCFC7hx2F/1DHCIe937nY+E9F/gSGA8yMDI2MTAxOTExMDYyOFowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTEwNjI4WjAvBgkqhkiG9w0BCQQxIgQgzKmPm3vOaJVXJHh+TOGKq0IH5FKWitxjflMU1sjMC+YwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIxAOLO3C1uXhuIblJmhrl9p+52WljjXS6WNZCM8LRTpBZypK+7tHlep20pH/zR8tOcHgIwXnHjC5///ogHMBvcKlpWIXE4AqP9IMAzJMb5JzYDRHkwTiZjDSZ513brynkXDE/I"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"VF1GU2Z6WchHrFOhTqp6f5n5v/bzA5xUzSRIyy7Jpts="},"signature":"MEUCIQD6FFMVe4TOTKoL6w1PXkQk5FGPLI7+GhSY6zV7QH656AIgNr9XKIy2SVm3TlD+bsk6yDu/doPItd5AEEXtFoWAqyE="}} \ No newline at end of file diff --git a/build/torch211-cu128-aarch64-linux/symbols.json b/build/torch211-cu128-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch211-cu128-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch211-cu130-aarch64-linux/__init__.py b/build/torch211-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/__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"] diff --git a/build/torch211-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch211-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..74dd076db1e1d69487d4e13e09a825dbdc6c9059 --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7c42f6f89e6b97f83c49ec4265ca7658bfc96e18f8ce0062017a8219a320446 +size 9846512 diff --git a/build/torch211-cu130-aarch64-linux/_ops.py b/build/torch211-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch211-cu130-aarch64-linux/layers.py b/build/torch211-cu130-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/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"] diff --git a/build/torch211-cu130-aarch64-linux/metadata.json b/build/torch211-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..aa88d724927fbbb7208f451c84f29ad98138c4f8 --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "t8Qvb4nmuX+DxJ7EJlynZYv8luGPjOAGIBeoIZoyBEY=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch211-cu130-aarch64-linux/metadata.json.sigstore b/build/torch211-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..47f6438de0734292a99abfe61eab0ff250939724 --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115252","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407989","inclusionPromise":{"signedEntryTimestamp":"MEUCIHV0aomB+qSgkLEl1qv3V3NnY+wEtDqOULXzMZkE9z2eAiEAiKTqVQcXX/NBBwM/D7UiV3uguz/tzSk856zBzInuI/w="},"inclusionProof":{"logIndex":"3198210990","rootHash":"O9i2T6AdIEt5WNEoDVKQ9Z2z9k/n4AQrGf78b5vfIsc=","treeSize":"3198210991","hashes":["bN0raIkzB5a2YQJJLgitoVGApO/PVbzgyM9yE92z7sY=","JXq45nyUD+18gxWVR7NHrlGTKP5uLWCB2JwnQv5tTdM=","0+i3hnyBTMZTHNbL+ANxqHr7UMVgYYaJYkQPG0gmVTg=","l5VM+Pc0WSXhK75AwCixEtM03fGoIYvLxc4OSuNkKNc=","GuVvnGqaFV7gJ3r7URJzep/H3YozPXfaZGzcmRhfZ+8=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198210991\nO9i2T6AdIEt5WNEoDVKQ9Z2z9k/n4AQrGf78b5vfIsc=\n\n— rekor.sigstore.dev wNI9ajBEAiAuUQMhBOXj1mOFCkl6qSptka52CKJtd+dxFJoWbJar5wIgQmgbylIqnMhGbDabxw7sMhF+YPUc8WMEKVOg0zXDDt8=\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQg8YyBX2pY+I4UPNmiDQKtIb8L9Q4ysuo/FKMJYCvexIUCFQCmZpsibap8FXOaZkoa4aO4kIy9AxgPMjAyNjEwMTkxMTA2MjhaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHaMIIB1gIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTExMDYyOFowLwYJKoZIhvcNAQkEMSIEIKpGda3coHXUu8rLq2VjwmYZxjtTpU6gvqmFKZ/jKcT1MIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRmMGQCMB/0XFKAtedcJGIftsDeIYM5qHaMZmxgBHJISyxC27lzTqfL4W50gR66M/0rOVIwgwIwac7s7ZwIcsrfSwhZpGoLcYANn1E/vpLWi/cwGdY3/Ux7muqboh+E4BjhHbSY7Ud1"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"wQ+sQLRJ53+kyVP/XmdRZdtpBnUAkjTm/oPG8G3daWM="},"signature":"MEUCIGT7X0b+z5Jwuw9CZOeXP3P14ymBPnlPbDxICffaXFB4AiEAmaAPvlnkhiaou5l+PmKJPw20ol75WnAblsbbkUMnP60="}} \ No newline at end of file diff --git a/build/torch211-cu130-aarch64-linux/symbols.json b/build/torch211-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch211-cu130-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch212-cu126-aarch64-linux/__init__.py b/build/torch212-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/__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"] diff --git a/build/torch212-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch212-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..0e1b8b900b8a79304fb2a0c4e3a9b281be56a828 --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1c54e6542d1ce54d8c64138f8c42f261303bcc65fa7d6b0d1b114f9c6407905 +size 6661240 diff --git a/build/torch212-cu126-aarch64-linux/_ops.py b/build/torch212-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch212-cu126-aarch64-linux/layers.py b/build/torch212-cu126-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/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"] diff --git a/build/torch212-cu126-aarch64-linux/metadata.json b/build/torch212-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bf165062e627e3c68e06f02a38edb88ebe432a90 --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/metadata.json @@ -0,0 +1,43 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "scVOZULRzlTYxkE4+MQvJhMDvMZfp9aw0bEU+cZAeQU=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch212-cu126-aarch64-linux/metadata.json.sigstore b/build/torch212-cu126-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..37e5c679fe84f343cd3f070e36468334ec654f82 --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"MIIHKzCCBrKgAwIBAgIUBAkY/3Na9ChGbPlisHQJHKEcpAIwCgYIKoZIzj0EAwMwNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRlcm1lZGlhdGUwHhcNMjYxMDE5MTEwNjI5WhcNMjYxMDE5MTExNjI5WjAAMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEYo7aneusgt/2w7sYhzGorCQBo4y2Y2cSBlU+6mOOxI5AV1uNYDkTWRZk3xuUCIsS1d921FjU04c7gQgZ9t06r6OCBdEwggXNMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAfBgNVHSMEGDAWgBTf0+nPViQRlvmo2OkoVaLGLhhkPzBrBgNVHREBAf8EYTBfhl1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOQYKKwYBBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50LmNvbTAfBgorBgEEAYO/MAECBBF3b3JrZmxvd19kaXNwYXRjaDA2BgorBgEEAYO/MAEDBChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBMGCisGAQQBg78wAQQEBUJ1aWxkMCsGCisGAQQBg78wAQUEHWh1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5MB0GCisGAQQBg78wAQYED3JlZnMvaGVhZHMvbWFpbjA7BgorBgEEAYO/MAEIBC0MK2h0dHBzOi8vdG9rZW4uYWN0aW9ucy5naXRodWJ1c2VyY29udGVudC5jb20wbQYKKwYBBAGDvzABCQRfDF1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOAYKKwYBBAGDvzABCgQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBsGCisGAQQBg78wAQsEDQwLc2VsZi1ob3N0ZWQwQAYKKwYBBAGDvzABDAQyDDBodHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkwOAYKKwYBBAGDvzABDQQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMB8GCisGAQQBg78wAQ4EEQwPcmVmcy9oZWFkcy9tYWluMBoGCisGAQQBg78wAQ8EDAwKMTA3MTQ3NTUyOTAuBgorBgEEAYO/MAEQBCAMHmh0dHBzOi8vZ2l0aHViLmNvbS9odWdnaW5nZmFjZTAYBgorBgEEAYO/MAERBAoMCDI1NzIwNzQzMG0GCisGAQQBg78wARIEXwxdaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5Ly5naXRodWIvd29ya2Zsb3dzL2J1aWxkLnlhbWxAcmVmcy9oZWFkcy9tYWluMDgGCisGAQQBg78wARMEKgwoZmUyYmI2NmZlZTZjMmE3N2VjY2YwOGEwNTA4ZGM1NzQyOGQ0ODhlZDAhBgorBgEEAYO/MAEUBBMMEXdvcmtmbG93X2Rpc3BhdGNoMGQGCisGAQQBg78wARUEVgxUaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5L2FjdGlvbnMvcnVucy8zOTIzOTUzNzc0Ni9hdHRlbXB0cy8xMBYGCisGAQQBg78wARYECAwGcHVibGljMEYGCisGAQQBg78wARgEOAw2cmVwbzpodWdnaW5nZmFjZS9rZXJuZWxzLWNvbW11bml0eTpyZWY6cmVmcy9oZWFkcy9tYWluMIGKBgorBgEEAdZ5AgQCBHwEegB4AHYA3T0wasbHETJjGR4cmWc3AqJKXrjePK3/h4pygC8p7o4AAAGhU9dtEgAABAMARzBFAiEAuNZbVz6dcBheA7RUGJAuBe/LTpxuOQ0AkE9jkdqEzkICIGAGB63t6kC6a+NCH1+emYRUZBs044Vja8Fep95E4LLEMAoGCCqGSM49BAMDA2cAMGQCMA9faF7NNiJ5NyH8GJ3EwLn1+uPIWpeG+05ovjfqx8ewBC04R6eXLqEjgR24gk6a3wIwCLs6d3mGcP5q2ofldsNvHdILs84469JtoZ9Zmux0+hgyoFiSThQe9qdXge6aBEz1"},"tlogEntries":[{"logIndex":"3320115263","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407989","inclusionPromise":{"signedEntryTimestamp":"MEQCIFheP0ma30IhPHZ5M+WDheMhOv90h+64c3gnM03AZ1BAAiAwxLGvR/+3LNMus9TqXZTvEjBphaqW4GxwWF2cK31o+Q=="},"inclusionProof":{"logIndex":"3198211001","rootHash":"KAFx9BgbKHzmHFvQa53QiQ+/RPx1W9BDKxv0XWi+feE=","treeSize":"3198211002","hashes":["/8MRMASy24RWPD3A4GY27Gs02qDjPHeG0/TtPk1yS6I=","7sG3BqDvkXQIuD+uxBgg8l4qDs/QpfnNPJRS8WDVRJs=","zp3IC5Hkuc5vTMBJTH0zjSALyIz67+m17XfBD9IjLGI=","l5VM+Pc0WSXhK75AwCixEtM03fGoIYvLxc4OSuNkKNc=","GuVvnGqaFV7gJ3r7URJzep/H3YozPXfaZGzcmRhfZ+8=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211002\nKAFx9BgbKHzmHFvQa53QiQ+/RPx1W9BDKxv0XWi+feE=\n\n— rekor.sigstore.dev wNI9ajBEAiAfzojmfe52joPP+eH2mpmvAS9ucZdouh7+DYNdfXjujwIgZSL+UU5N+gTOSkCDVlcz1k0QbAWjazw0kD1qW1G+tW8=\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgUZBHaPvkgcI/uxprQHFOfRW1eZofREiuxqTLkVzbp08CFDIY7XpnYcg+C+asCu1o98y5jbF3GA8yMDI2MTAxOTExMDYyOVowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdwwggHYAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTEwNjI5WjAvBgkqhkiG9w0BCQQxIgQgPh1BeP4XgNtWXjp7RH0S8UIeBY+r2e+WbxIrzzPxemowgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGgwZgIxAMSwokdMxTVBPaNOvqOycNSgrOWhFEdScxQ7lANw/IIcL4SveU13CiB7zf0EWhBDqQIxAIcLY0WDsv8RVOjyZnYhQb8SwIXfVPtlHVQ89Z+SkWyxcz5es8yQlhvJr0Szm6oeIQ=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"3k6qTPvJzuyJWoLBcE4OY/Xa6vka6mKfe4JOtp5Uohs="},"signature":"MEYCIQCKwsxYZtG0LlmoEB6z+Qx5iGrpPLlvIs0U9/HQsPsX0gIhALUC+/hGJmAdKuCbbAHIrWIH9+K9B4SW+Anf/P6NoIuo"}} \ No newline at end of file diff --git a/build/torch212-cu126-aarch64-linux/symbols.json b/build/torch212-cu126-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch212-cu126-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch212-cu130-aarch64-linux/__init__.py b/build/torch212-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/__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"] diff --git a/build/torch212-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch212-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..4c4c1567f6a72ecb93a22c0ebc8a92890c9ebf0c --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9b8137e5bae873f0aa806df9df77095620e224784da4206f19291adf7b52521b +size 9846680 diff --git a/build/torch212-cu130-aarch64-linux/_ops.py b/build/torch212-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch212-cu130-aarch64-linux/layers.py b/build/torch212-cu130-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/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"] diff --git a/build/torch212-cu130-aarch64-linux/metadata.json b/build/torch212-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..180a4087abf9837f4262efee41d2b96fd557bc42 --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "m4E35broc/CqgG3533cJViDiJHhNpCBvGSka33tSUhs=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch212-cu130-aarch64-linux/metadata.json.sigstore b/build/torch212-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..b43c63ec1f4d3fc7b340a36a16fe929d64adfb4f --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115276","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407990","inclusionPromise":{"signedEntryTimestamp":"MEQCIFCpRQauwnwWiQfNafpNlqF882bwydV2uYvIeXhHoDXSAiAuTqJS0O0uJg8RnqJKstkzzDMez1jlK8iVOmSudSgMNg=="},"inclusionProof":{"logIndex":"3198211014","rootHash":"YP4Q/rlQQl28YOLuFPyMw0ozXusTru85blKlk80vu40=","treeSize":"3198211016","hashes":["6aakIPr5FC7BuvQamQXH2PLYtibBRj4Nv2PuFVBZ5Jg=","vELkUfEye2tVyzzZka7bqp+RHbko+NkR4pjTD9IU/j8=","/dFaA5tDo2konOeJ9Yo4hFt5aC9X6yUFKQrRT8YIFyI=","2s85e20iBoWz0pz9KzMk2WEnp5vODh2nu14MF9pUepo=","GuVvnGqaFV7gJ3r7URJzep/H3YozPXfaZGzcmRhfZ+8=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211016\nYP4Q/rlQQl28YOLuFPyMw0ozXusTru85blKlk80vu40=\n\n— rekor.sigstore.dev wNI9ajBFAiEAvkj4ncx06/7zQlN+WSP31bqXi02EJJ828YZRK3k2IOMCID8CdFbNkwstZDc92MfBGlDFz07ByHSJTtMnG+/zD18b\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgleAnwKZVOf8Ki8gJPWYbLUU4JJk+5XafAS1JGSvXpXsCFQCRF0RNAaTpokievhrrsJHA1JSq5hgPMjAyNjEwMTkxMTA2MzBaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHaMIIB1gIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTExMDYzMFowLwYJKoZIhvcNAQkEMSIEIDTIGB97olxFrVRmpl7hY+9f+L2/GpB379Fzc0ud2G1zMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRmMGQCMCBgaiHiD0Yy6HAeuo+AXBYapCFtPEKyHebrDBb5m8OKZtJKdQK7ayMsJXUAGrnHVAIwb0xEYcegXqDbQK/Mco6JmPreG7LEZXwP88Il+KBJGZr/W7AWw3Ce6YcSceGGPQCE"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"aJG9Z03gZ9SDMKaBjyXsBv5NMC9BdtPBrNp3fAqETaQ="},"signature":"MEQCIHfAhyPpZo3OBtl9q1WjkfUsUwJP3Q44Yqx4mpUHlwBcAiBl79Amc2cTXTJCb1NpAquSsQCuekw19BilCz3jdwvsjg=="}} \ No newline at end of file diff --git a/build/torch212-cu130-aarch64-linux/symbols.json b/build/torch212-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch212-cu130-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch212-cu132-aarch64-linux/__init__.py b/build/torch212-cu132-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/__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"] diff --git a/build/torch212-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch212-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..177c5bcdf2a7f1793673e142a424263b331b62ef --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:511beeddee7940d051d97288acdf0dd410b792569f6f357f71a91f52be58cb03 +size 9980528 diff --git a/build/torch212-cu132-aarch64-linux/_ops.py b/build/torch212-cu132-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch212-cu132-aarch64-linux/layers.py b/build/torch212-cu132-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/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"] diff --git a/build/torch212-cu132-aarch64-linux/metadata.json b/build/torch212-cu132-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..757d4296e4dac8c4540c167ba86247fd841be482 --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "URvu3e55QNBR2XKIrN8N1BC3klafbzV/cakfUr5YywM=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch212-cu132-aarch64-linux/metadata.json.sigstore b/build/torch212-cu132-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..d8207a75048227bd694eee8baf6599f59fe5decd --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115296","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407991","inclusionPromise":{"signedEntryTimestamp":"MEUCIQD6IMkxjjQQGbBJfO0Rf+t5xpJ/I7UF3szKLSqMsuTVfwIgDDX1Aqne1MXEd1dfOTuqgudJucfGaurq6pGrct96zLc="},"inclusionProof":{"logIndex":"3198211034","rootHash":"HVINv7GCZopKhtGEtKIoRcchkePVIqJeYhIWQVQe/G4=","treeSize":"3198211036","hashes":["PxLNyp1HRg90ml/eV3X18ZyHipw6TZL94tIpVk2hS5A=","kKolWcl5khyTsI8XfA8vK01QkC24mmBaVPX9p3cu7sw=","zyUlWdfmYjJ1aK01jwa1Y7g0v/iEqmzvtQZJecLXf74=","HM+VJZ6NcyHN67YkOcioHzSqPgDwqV49/sBsOKs0jDU=","2s85e20iBoWz0pz9KzMk2WEnp5vODh2nu14MF9pUepo=","GuVvnGqaFV7gJ3r7URJzep/H3YozPXfaZGzcmRhfZ+8=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211036\nHVINv7GCZopKhtGEtKIoRcchkePVIqJeYhIWQVQe/G4=\n\n— rekor.sigstore.dev wNI9ajBFAiAgpE0kuQqVHinjQvnmCZsSKYu4ibBhnKYom28FEAAP4AIhAN4LGGOXS1SiR0yCMjipGIqGW8cKCi8ov23Kp5UetAmZ\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgfY4FocutqovtI6GP6iKU2sIdL9UiT4kY/1eSqZyh884CFGCOvUNRqa95UGkOVGnl9SDTY5zFGA8yMDI2MTAxOTExMDYzMVowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdwwggHYAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTEwNjMxWjAvBgkqhkiG9w0BCQQxIgQgUYigWacxUsy3XLXPA6CbDtcrfCCbHXlg2ECoa2GPAxEwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGgwZgIxAPtFc7OwmJjlXrq74b5xvJjipQN4d7O8bkLU+ojh7XxuUwCe3pJuubtv3+s9vpDwtgIxAKMaRvwlg4jglFkFpUpn10f25BiyZLOs9Ucm2MxUQBlNnoU0RlaSFLue0C9ouVL9MA=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"9LAIGjSyoucoxsr8PlfR5rNkgUFapenhQZbmlmWleMU="},"signature":"MEUCIDDEgglg1045CUD6rvWJ0S2u0mlVyA/8djGns0EXM+CSAiEA4V7uwDuO3/PNjmjN5tQX3xOO+sEluEmNJF991rcLxK0="}} \ No newline at end of file diff --git a/build/torch212-cu132-aarch64-linux/symbols.json b/build/torch212-cu132-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch212-cu132-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch213-cu126-aarch64-linux/__init__.py b/build/torch213-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/__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"] diff --git a/build/torch213-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch213-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..0bd0daf6402d553c4ba01106cd3f31d8ad5cfa69 --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:226e5686ad1a5c052046ec33c17ba6ad84629502b341ec81eb68f1b981ee7345 +size 6661304 diff --git a/build/torch213-cu126-aarch64-linux/_ops.py b/build/torch213-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch213-cu126-aarch64-linux/layers.py b/build/torch213-cu126-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/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"] diff --git a/build/torch213-cu126-aarch64-linux/metadata.json b/build/torch213-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..560546a75a9dfd22642260f94fd5a85255a0f270 --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/metadata.json @@ -0,0 +1,43 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "Im5Whq0aXAUgRuwzwXumrYRilQKzQeyB62jxuYHuc0U=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch213-cu126-aarch64-linux/metadata.json.sigstore b/build/torch213-cu126-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..097c7d61344dd4c916c0e7f0a0bc4422b3b23e21 --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115303","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407992","inclusionPromise":{"signedEntryTimestamp":"MEUCIQCWcstvOdtCPaaGa33wVM6wOYB5uelBmmBdpx1f57KblgIgY4oTvW+CIlgJn0cEcAqArPgRxzAJdHPrXyet3Hn9a+4="},"inclusionProof":{"logIndex":"3198211041","rootHash":"WZDJ8JpLjQ9gMUYoXo3C5n8B8pDfcxa2bmvub3jJmlE=","treeSize":"3198211043","hashes":["OY4JKgZ2y+8kdJr3yuj1lWxIKXhGaef4tEj2uHCMftA=","RyO4AD8nTiuPmZve5FLhYunFI4s7gcHjC3DTnapJtqw=","nDX4JijtHovkEeLnlj5KtmmYGbFhiQfrUKC1Dd5qx7o=","2s85e20iBoWz0pz9KzMk2WEnp5vODh2nu14MF9pUepo=","GuVvnGqaFV7gJ3r7URJzep/H3YozPXfaZGzcmRhfZ+8=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211043\nWZDJ8JpLjQ9gMUYoXo3C5n8B8pDfcxa2bmvub3jJmlE=\n\n— rekor.sigstore.dev wNI9ajBFAiEAz8TLc3g/L34ncOO5rGGf97bM8X6BRt7tPqfvAqR41/cCIHFm4YB3fvwOa46F7zsTuTlmDmrk/Lx2DU3DBUnDQOBT\n"}},"canonicalizedBody":"eyJhcGlWZXJzaW9uIjoiMC4wLjEiLCJraW5kIjoiaGFzaGVkcmVrb3JkIiwic3BlYyI6eyJkYXRhIjp7Imhhc2giOnsiYWxnb3JpdGhtIjoic2hhMjU2IiwidmFsdWUiOiIzZTYxZGZmYjk3YjZjOTRlNzI2OTVmNjQ3M2I5OWQyMmQyYzBmYTNhNDQzZDgwZGFiZDcyMTFjOTJjNmY3N2Y4In19LCJzaWduYXR1cmUiOnsiY29udGVudCI6Ik1FWUNJUUR3amNtanduK3NSMEUzYjlwdE1rbm9PQ3pwZm9uZDlJcSs5cmE3SkJzM0VBSWhBSk0rYklEem9hNnQ4aWp0enY1d0xtYVJZWWtCTU80WTQwbjFIV1JlYlIrTyIsInB1YmxpY0tleSI6eyJjb250ZW50IjoiTFMwdExTMUNSVWRKVGlCRFJWSlVTVVpKUTBGVVJTMHRMUzB0Q2sxSlNVaExla05EUW5KSFowRjNTVUpCWjBsVlpsbHlaREZ5WmxKa1dGbEVXSEZHUTFWc2VURlFjMlJCY0ZrMGQwTm5XVWxMYjFwSmVtb3dSVUYzVFhjS1RucEZWazFDVFVkQk1WVkZRMmhOVFdNeWJHNWpNMUoyWTIxVmRWcEhWakpOVWpSM1NFRlpSRlpSVVVSRmVGWjZZVmRrZW1SSE9YbGFVekZ3WW01U2JBcGpiVEZzV2tkc2FHUkhWWGRJYUdOT1RXcFplRTFFUlRWTlZFVjNUbXBOZUZkb1kwNU5hbGw0VFVSRk5VMVVSWGhPYWsxNFYycEJRVTFHYTNkRmQxbElDa3R2V2tsNmFqQkRRVkZaU1V0dldrbDZhakJFUVZGalJGRm5RVVV6UVRrMFRYRkhjbkJNWW5kUWRESktVVzgyTld4Q04xUjBiM052VGxKS2JERlZXRThLV0cxNk1VbDJkRkowYzJwTlpFWTNUblJvTUU1eVdXMXVSemxaYTFCVFZWZHZjVWdyTVVWWlQwcFZURkJKYVdobmJFdFBRMEprUVhkbloxaE5UVUUwUndwQk1WVmtSSGRGUWk5M1VVVkJkMGxJWjBSQlZFSm5UbFpJVTFWRlJFUkJTMEpuWjNKQ1owVkdRbEZqUkVGNlFXWkNaMDVXU0ZOTlJVZEVRVmRuUWxSbUNqQXJibEJXYVZGU2JIWnRiekpQYTI5V1lVeEhUR2hvYTFCNlFuSkNaMDVXU0ZKRlFrRm1PRVZaVkVKbWFHd3hiMlJJVW5kamVtOTJUREprY0dSSGFERUtXV2sxYW1JeU1IWmhTRlp1V2pKc2RWb3lXbWhaTWxWMllUSldlV0p0Vm5OamVURnFZakl4ZEdSWE5YQmtTR3QyVEcxa2NHUkhhREZaYVRrellqTktjZ3BhYlhoMlpETk5kbGx1Vm5CaVIxRjFaVmRHZEdKRlFubGFWMXA2VERKb2JGbFhVbnBNTWpGb1lWYzBkMDlSV1V0TGQxbENRa0ZIUkhaNlFVSkJVVkZ5Q21GSVVqQmpTRTAyVEhrNU1HSXlkR3hpYVRWb1dUTlNjR0l5TlhwTWJXUndaRWRvTVZsdVZucGFXRXBxWWpJMU1GcFhOVEJNYlU1MllsUkJaa0puYjNJS1FtZEZSVUZaVHk5TlFVVkRRa0pHTTJJelNuSmFiWGgyWkRFNWEyRllUbmRaV0ZKcVlVUkJNa0puYjNKQ1owVkZRVmxQTDAxQlJVUkNRMmh0V2xSS2FRcFphbGt5V20xV2JFNXRUWGxaVkdNeldsZE9hbHBxUVRSWlZFRXhUVVJvYTFsNlZUTk9SRWswV2tSUk5FOUhWbXROUWsxSFEybHpSMEZSVVVKbk56aDNDa0ZSVVVWQ1ZVb3hZVmQ0YTAxRGMwZERhWE5IUVZGUlFtYzNPSGRCVVZWRlNGZG9NVm95WkhCaWJXUnRXVmRPYkV3eWRHeGpiVFZzWWtoTmRGa3lPWFFLWWxoV2RXRllValZOUWpCSFEybHpSMEZSVVVKbk56aDNRVkZaUlVRelNteGFiazEyWVVkV2FGcElUWFppVjBad1ltcEJOMEpuYjNKQ1owVkZRVmxQTHdwTlFVVkpRa013VFVzeWFEQmtTRUo2VDJrNGRtUkhPWEphVnpSMVdWZE9NR0ZYT1hWamVUVnVZVmhTYjJSWFNqRmpNbFo1V1RJNWRXUkhWblZrUXpWcUNtSXlNSGRpVVZsTFMzZFpRa0pCUjBSMmVrRkNRMUZTWmtSR01XOWtTRkozWTNwdmRrd3laSEJrUjJneFdXazFhbUl5TUhaaFNGWnVXakpzZFZveVdtZ0tXVEpWZG1FeVZubGliVlp6WTNreGFtSXlNWFJrVnpWd1pFaHJka3h0WkhCa1IyZ3hXV2s1TTJJelNuSmFiWGgyWkROTmRsbHVWbkJpUjFGMVpWZEdkQXBpUlVKNVdsZGFla3d5YUd4WlYxSjZUREl4YUdGWE5IZFBRVmxMUzNkWlFrSkJSMFIyZWtGQ1EyZFJjVVJEYUcxYVZFcHBXV3BaTWxwdFZteE9iVTE1Q2xsVVl6TmFWMDVxV21wQk5GbFVRVEZOUkdocldYcFZNMDVFU1RSYVJGRTBUMGRXYTAxQ2MwZERhWE5IUVZGUlFtYzNPSGRCVVhORlJGRjNUR015Vm5NS1dta3hiMkl6VGpCYVYxRjNVVUZaUzB0M1dVSkNRVWRFZG5wQlFrUkJVWGxFUkVKdlpFaFNkMk42YjNaTU1tUndaRWRvTVZscE5XcGlNakIyWVVoV2JncGFNbXgxV2pKYWFGa3lWWFpoTWxaNVltMVdjMk41TVdwaU1qRjBaRmMxY0dSSWEzZFBRVmxMUzNkWlFrSkJSMFIyZWtGQ1JGRlJjVVJEYUcxYVZFcHBDbGxxV1RKYWJWWnNUbTFOZVZsVVl6TmFWMDVxV21wQk5GbFVRVEZOUkdocldYcFZNMDVFU1RSYVJGRTBUMGRXYTAxQ09FZERhWE5IUVZGUlFtYzNPSGNLUVZFMFJVVlJkMUJqYlZadFkzazViMXBYUm10amVUbDBXVmRzZFUxQ2IwZERhWE5IUVZGUlFtYzNPSGRCVVRoRlJFRjNTMDFVUVROTlZGRXpUbFJWZVFwUFZFRjFRbWR2Y2tKblJVVkJXVTh2VFVGRlVVSkRRVTFJYldnd1pFaENlazlwT0haYU1td3dZVWhXYVV4dFRuWmlVemx2WkZka2JtRlhOVzVhYlVacUNscFVRVmxDWjI5eVFtZEZSVUZaVHk5TlFVVlNRa0Z2VFVORVNURk9la2wzVG5wUmVrMUhNRWREYVhOSFFWRlJRbWMzT0hkQlVrbEZXSGQ0WkdGSVVqQUtZMGhOTmt4NU9XNWhXRkp2WkZkSmRWa3lPWFJNTW1neFdqSmtjR0p0WkcxWlYwNXNUREowYkdOdE5XeGlTRTEwV1RJNWRHSllWblZoV0ZJMVRIazFiZ3BoV0ZKdlpGZEpkbVF5T1hsaE1scHpZak5rZWt3eVNqRmhWM2hyVEc1c2FHSlhlRUZqYlZadFkzazViMXBYUm10amVUbDBXVmRzZFUxRVowZERhWE5IQ2tGUlVVSm5OemgzUVZKTlJVdG5kMjlhYlZWNVdXMUpNazV0V214YVZGcHFUVzFGTTA0eVZtcFpNbGwzVDBkRmQwNVVRVFJhUjAweFRucFJlVTlIVVRBS1QwUm9iRnBFUVdoQ1oyOXlRbWRGUlVGWlR5OU5RVVZWUWtKTlRVVllaSFpqYlhSdFlrYzVNMWd5VW5Cak0wSm9aRWRPYjAxSFVVZERhWE5IUVZGUlFncG5OemgzUVZKVlJWWm5lRlZoU0ZJd1kwaE5Oa3g1T1c1aFdGSnZaRmRKZFZreU9YUk1NbWd4V2pKa2NHSnRaRzFaVjA1c1RESjBiR050Tld4aVNFMTBDbGt5T1hSaVdGWjFZVmhTTlV3eVJtcGtSMngyWW01TmRtTnVWblZqZVRoNlQxUkplazlVVlhwT2VtTXdUbWs1YUdSSVVteGlXRUl3WTNrNGVFMUNXVWNLUTJselIwRlJVVUpuTnpoM1FWSlpSVU5CZDBkalNGWnBZa2RzYWsxRldVZERhWE5IUVZGUlFtYzNPSGRCVW1kRlQwRjNNbU50Vm5kaWVuQnZaRmRrYmdwaFZ6VnVXbTFHYWxwVE9YSmFXRXAxV2xkNGVreFhUblppVnpFeFltMXNNR1ZVY0hsYVYxazJZMjFXYldONU9XOWFWMFpyWTNrNWRGbFhiSFZOU1VkS0NrSm5iM0pDWjBWRlFXUmFOVUZuVVVOQ1NITkZaVkZDTTBGSVZVRXpWREIzWVhOaVNFVlVTbXBIVWpSamJWZGpNMEZ4U2t0WWNtcGxVRXN6TDJnMGNIa0taME00Y0Rkdk5FRkJRVWRvVlRsa01tNUJRVUZDUVUxQlVtcENSVUZwUWt4cGVHUmtXVzFoT1RkVllqZGhjVE5KTkRGNWQwUnhXV2hKYkhWVldrMUJNd3BqZGtsdVpITTNOVzFSU1dkaVZUZHNia3hsVGlzMWNqRlJZVzl2ZWxZNGRqZFNiRk5wWldZeVZqQkhOazlhSzBaMGFHaFVTRVEwZDBObldVbExiMXBKQ25wcU1FVkJkMDFFWVVGQmQxcFJTWGRLVTNjMWExSkpaWGxTZUdoMFRrOW9NRTlMUW5wNVJVc3pORTB5U0dkaGFIRTJTMGxXUTJrd2NsbG1PRll3Wm5nS1ZXcEVOVlJMTmpSRGJuWXlTR3hzVTBGcVJVRTVaMVpITVVKVVFsZFNTa2xKY1V4R2VucG5aekpzVW1aRUwwUXJOWFExY1dwSGFWUnJhVGwyZG1OMWVBcFJVM1J2V0V0UmFTdDRZVVp1VG1GQldsUmFkZ290TFMwdExVVk9SQ0JEUlZKVVNVWkpRMEZVUlMwdExTMHRDZz09In19fX0="}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQg3T7mSfF8UL6ZA6Y3uPl7GIBN2zDQiJyXHP+6apENhFYCFQDHENvXBfeD97oW74u+gh3QtnqQkxgPMjAyNjEwMTkxMTA2MzJaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTExMDYzMlowLwYJKoZIhvcNAQkEMSIEIB4xe1nKEBMPq4D/6VQQTnSqiwbYVB/vfH64OgfiVJoJMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMC76ZLJSUBx5fK/7wo1+H6EwE9Zpv1XQIyBlFyT0Dd9A7TU5x4K92n0GLeFwRU/uyAIxAK+ueQMszn0tttkQOmv3Ykg9aaIjL/28yC+Ueb9/2XkiC7dwzjZt5GKjJZ33Gm2lAA=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"PmHf+5e2yU5yaV9kc7mdItLA+jpEPYDavXIRySxvd/g="},"signature":"MEYCIQDwjcmjwn+sR0E3b9ptMknoOCzpfond9Iq+9ra7JBs3EAIhAJM+bIDzoa6t8ijtzv5wLmaRYYkBMO4Y40n1HWRebR+O"}} \ No newline at end of file diff --git a/build/torch213-cu126-aarch64-linux/symbols.json b/build/torch213-cu126-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch213-cu126-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch213-cu130-aarch64-linux/__init__.py b/build/torch213-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/__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"] diff --git a/build/torch213-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch213-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..e45cf231328a9c2996ea7ce38ff77caf04e5be94 --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dffe6431c93bf0633495dcf70f935a5453d78b9aef1d5689b080e72a7d8eba70 +size 9846568 diff --git a/build/torch213-cu130-aarch64-linux/_ops.py b/build/torch213-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch213-cu130-aarch64-linux/layers.py b/build/torch213-cu130-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/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"] diff --git a/build/torch213-cu130-aarch64-linux/metadata.json b/build/torch213-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ca0412d74a15e30c668afd8dc674ee480966a320 --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "3/5kMck78GM0ldz3D5NaVFPXi5rvHVaJsIDnKn2OunA=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch213-cu130-aarch64-linux/metadata.json.sigstore b/build/torch213-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..16f0cfbe68f0cbc703cfad9ae0432da249308b79 --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115320","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407993","inclusionPromise":{"signedEntryTimestamp":"MEYCIQC5wfV7+DDMp7XuNybL+pVTUsRMK3zPgpfsnmXGginaLAIhAO17yRBPS9OyjtKlfguukJUVJ08MtxBDYWKlGBziPfOr"},"inclusionProof":{"logIndex":"3198211058","rootHash":"vjvmp2lw8Jn+3T7+zHXuBKT2ZANogEpXxLxBZeLtBVo=","treeSize":"3198211063","hashes":["qNTWf6VbKzJwzuarlGQhXxhHojg0huK3ohjYMJrGTbw=","E4CfRWVZEIzTxnXG6NrhuE0NNMU+g9G2T1F6RbL39x8=","v4B2/aVgHGmdt9VnyKzM0rV5H+WY2050B0/kKZ3iQbg=","fbAOj03KTNFlcCsmeTlZQKDQJx/jcwxfGXn9z0QF0zU=","nDX4JijtHovkEeLnlj5KtmmYGbFhiQfrUKC1Dd5qx7o=","2s85e20iBoWz0pz9KzMk2WEnp5vODh2nu14MF9pUepo=","GuVvnGqaFV7gJ3r7URJzep/H3YozPXfaZGzcmRhfZ+8=","XeJRfO8GGqdVjjDSrcs8+Wc5QwvXThQ63MFVLW5wtfo=","s9iN9HHBoxC2mbJmeUlysJhmQiWhVMF8kCCF2P6eLgU=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211063\nvjvmp2lw8Jn+3T7+zHXuBKT2ZANogEpXxLxBZeLtBVo=\n\n— rekor.sigstore.dev wNI9ajBGAiEAjkqQheSpYkLZdgIt4T/hLUEOAxt1UYjo9SP8j0VzrOYCIQCt7WDzIDFcYQEjwWqpl0xzeL7YZaxVpQXKU9pxp0VgpA==\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQg0XqnCATDYTHIusc0A3PBd2PcnPy45nzJqG9E0fIbVeYCFAFV3W8okeUnhQF6TsdPPlGU5L/hGA8yMDI2MTAxOTExMDYzMlowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTEwNjMyWjAvBgkqhkiG9w0BCQQxIgQgqMT8tCEBjAAea/bFMZ9ii0K+IV4wAFT/u3PwdcF2jJswgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIxANVDaRUaOwxHh9j0LY1pzpT9maqGEGcpux+aQAtjC0h2hg+oHc699fv/vHbrL4yoUwIwVoFYLSA9eMAGpRSC6f/qgxeaCeM/3eDRZTFBeQ1rzrm9YXyJ6+Cf2APWKlGnQLWq"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"KnKo51B+8oq6t9Su4zWh67d2V+9IqVKepqGpY0mO4Fk="},"signature":"MEUCIHalYdZuSk740wCWdfgI8WuIz2F8wmugu8Fbb9fKsbQRAiEApLuC+RBE1ahE7X+tIUVHEVNmnpgbhokThCmt+KvKLpA="}} \ No newline at end of file diff --git a/build/torch213-cu130-aarch64-linux/symbols.json b/build/torch213-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch213-cu130-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch213-cu132-aarch64-linux/__init__.py b/build/torch213-cu132-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/__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"] diff --git a/build/torch213-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch213-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..998b5a5cfbff681391d3c8a50dc6a62aa240b8f7 --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:77f89e077d2466b91ba0be7fc8078f61aa7672077ffc41d5bc293b89e2795f83 +size 9980416 diff --git a/build/torch213-cu132-aarch64-linux/_ops.py b/build/torch213-cu132-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch213-cu132-aarch64-linux/layers.py b/build/torch213-cu132-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/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"] diff --git a/build/torch213-cu132-aarch64-linux/metadata.json b/build/torch213-cu132-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..1fc8282316acfb947da034c0ecb42978a4151416 --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "d/ieB30kZrkboL5/yAePYap2cgd//EHVvCk7ieJ5X4M=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch213-cu132-aarch64-linux/metadata.json.sigstore b/build/torch213-cu132-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..72fed93ae0b8f4a034a784edfc91efd5a68be4a5 --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115341","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407993","inclusionPromise":{"signedEntryTimestamp":"MEYCIQDcFhxxgIY2l6ptTkm4YPQP69tXTF0VOl4nVb0ErVNPvwIhANUF2tioi+9z6b7yIDFFz3WzID5yKBRnq8MqVh6EWiSB"},"inclusionProof":{"logIndex":"3198211079","rootHash":"9JopWQi2D9mVTgr+wty3fV15X72ewIg67QeYKrwAmHk=","treeSize":"3198211084","hashes":["8OdHYKuKC5lUUUYm2xEJVy1UW5AW+l3kT3RUgL6xcCw=","MErT70zWS41RbMwgWShMSaHKtmWETv+j4ttvmnKPVhk=","J/EZREIcxFhPrsVm9Nq1Wb3VJ7NUBOxGHim5xOlRc08=","kvU8t5yzvJ+QcVZfJ+vaVO4Ps/MuU64JyRY8NP0ooZ4=","NvhAA1+LqtXvaowiFXcolXI/TyFO3CsufLfJu3VJv2k=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211084\n9JopWQi2D9mVTgr+wty3fV15X72ewIg67QeYKrwAmHk=\n\n— rekor.sigstore.dev wNI9ajBEAiBvEPsEC+7Na0N9iwCx7MCRWK+7ZbpISYbM4Da+7Zs9KAIgDsVgF7DziW04WNS6Ua3qPi5+cZg+0i7fvjUQGb/j8Oo=\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyDADAgEAMIICvwYJKoZIhvcNAQcCoIICsDCCAqwCAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQg2ZY6e6n0NHrhQ+tqOP1K1GkJszIsQHshTYqCBqe858QCFB+oRWFAVu0MVMtPxLmSUF7fHp1MGA8yMDI2MTAxOTExMDYzM1owAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdowggHWAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTEwNjMzWjAvBgkqhkiG9w0BCQQxIgQgkPUAgj7U7tZTn2xZTaubp+mAy5nsqe7XIbW+0wAb8S0wgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGYwZAIwenMx3Udn5bZD4PUjI4ngH9M2+5BFtOGehlkLsud434u3zzvlESvi7boJYYgzAaF9AjAsISxYw/rKMHIjSbpK82Bno9eIV5dQMUbwbvFIDyqpHdHn0DLL7d3KELFV8tP9Bro="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"yKQoSd7BXz79I5E4pg5uWGU9dk7jIMvdvcmrILH4wHU="},"signature":"MEQCIB+BmGwjb/wQjCdlSyltgqgaUF+887bJ1RuN3GBVLncaAiAuwNZQ3pqSfG3jNrZdiDyhfFXZFHsCZNFUSfnE7bWTbA=="}} \ No newline at end of file diff --git a/build/torch213-cu132-aarch64-linux/symbols.json b/build/torch213-cu132-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch213-cu132-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch214-cu126-aarch64-linux/__init__.py b/build/torch214-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/__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"] diff --git a/build/torch214-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch214-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..8b04d9aef7793f6ce4515bd94f7431c53e251cdc --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6a0a7fb38808634d8a6c86c994f90e753bfe527ff80a93f73ce59b4b4057838c +size 6661208 diff --git a/build/torch214-cu126-aarch64-linux/_ops.py b/build/torch214-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch214-cu126-aarch64-linux/layers.py b/build/torch214-cu126-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/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"] diff --git a/build/torch214-cu126-aarch64-linux/metadata.json b/build/torch214-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bcd91584c109e7e4ecfcaf9d86468b9d9390d7b8 --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/metadata.json @@ -0,0 +1,43 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "agp/s4gIY02KbIbJlPkOdTv+Un/4CpP3POWbS0BXg4w=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch214-cu126-aarch64-linux/metadata.json.sigstore b/build/torch214-cu126-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..f82d698a0430572d0f9114c19a172544d14be355 --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"MIIHKzCCBrGgAwIBAgIUMRAoaZ8qgp2gC3Iw8gil8yG0sdEwCgYIKoZIzj0EAwMwNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRlcm1lZGlhdGUwHhcNMjYxMDE5MTEwNjM0WhcNMjYxMDE5MTExNjM0WjAAMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEStO4egB6Xdc4iQqY/LpE487MgZSfClD+/bRRR1fhbbX4T2BnNrbzhS1QjcTgZiWuhA6U6qdI1a37y3fEbVmC56OCBdAwggXMMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAfBgNVHSMEGDAWgBTf0+nPViQRlvmo2OkoVaLGLhhkPzBrBgNVHREBAf8EYTBfhl1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOQYKKwYBBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50LmNvbTAfBgorBgEEAYO/MAECBBF3b3JrZmxvd19kaXNwYXRjaDA2BgorBgEEAYO/MAEDBChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBMGCisGAQQBg78wAQQEBUJ1aWxkMCsGCisGAQQBg78wAQUEHWh1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5MB0GCisGAQQBg78wAQYED3JlZnMvaGVhZHMvbWFpbjA7BgorBgEEAYO/MAEIBC0MK2h0dHBzOi8vdG9rZW4uYWN0aW9ucy5naXRodWJ1c2VyY29udGVudC5jb20wbQYKKwYBBAGDvzABCQRfDF1odHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGQueWFtbEByZWZzL2hlYWRzL21haW4wOAYKKwYBBAGDvzABCgQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMBsGCisGAQQBg78wAQsEDQwLc2VsZi1ob3N0ZWQwQAYKKwYBBAGDvzABDAQyDDBodHRwczovL2dpdGh1Yi5jb20vaHVnZ2luZ2ZhY2Uva2VybmVscy1jb21tdW5pdHkwOAYKKwYBBAGDvzABDQQqDChmZTJiYjY2ZmVlNmMyYTc3ZWNjZjA4YTA1MDhkYzU3NDI4ZDQ4OGVkMB8GCisGAQQBg78wAQ4EEQwPcmVmcy9oZWFkcy9tYWluMBoGCisGAQQBg78wAQ8EDAwKMTA3MTQ3NTUyOTAuBgorBgEEAYO/MAEQBCAMHmh0dHBzOi8vZ2l0aHViLmNvbS9odWdnaW5nZmFjZTAYBgorBgEEAYO/MAERBAoMCDI1NzIwNzQzMG0GCisGAQQBg78wARIEXwxdaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5Ly5naXRodWIvd29ya2Zsb3dzL2J1aWxkLnlhbWxAcmVmcy9oZWFkcy9tYWluMDgGCisGAQQBg78wARMEKgwoZmUyYmI2NmZlZTZjMmE3N2VjY2YwOGEwNTA4ZGM1NzQyOGQ0ODhlZDAhBgorBgEEAYO/MAEUBBMMEXdvcmtmbG93X2Rpc3BhdGNoMGQGCisGAQQBg78wARUEVgxUaHR0cHM6Ly9naXRodWIuY29tL2h1Z2dpbmdmYWNlL2tlcm5lbHMtY29tbXVuaXR5L2FjdGlvbnMvcnVucy8zOTIzOTUzNzc0Ni9hdHRlbXB0cy8xMBYGCisGAQQBg78wARYECAwGcHVibGljMEYGCisGAQQBg78wARgEOAw2cmVwbzpodWdnaW5nZmFjZS9rZXJuZWxzLWNvbW11bml0eTpyZWY6cmVmcy9oZWFkcy9tYWluMIGJBgorBgEEAdZ5AgQCBHsEeQB3AHUA3T0wasbHETJjGR4cmWc3AqJKXrjePK3/h4pygC8p7o4AAAGhU9eAlAAABAMARjBEAiBB3uH2/gKhchL3jwrYw28Ckn1666uYYsd5Tu1t1At7pwIgWaMXwo8PBRyzrX0i/Xlmemth+GqKqxLAZgqv3CWC5ckwCgYIKoZIzj0EAwMDaAAwZQIxAP9svaIvQDFaVYHy6hUFLPbJRfj+87LgFcfJktGNV6ijREZHdBvqkH8h+daf2RI68gIwXNKHVgqM8eoR5jrkMj8AsAZB0brFsSFkV9kPXCvjOx2J6aM1esZF8g70po0R5ItU"},"tlogEntries":[{"logIndex":"3320115352","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407994","inclusionPromise":{"signedEntryTimestamp":"MEQCIGeTWLko9fsrqW8fYDnDPuXoW7UQ7jQphy9+hfjA0aDHAiAC6YmcT5ydydr4Y5dLsVWIK1t/nSlnv5uVWcSWigZtrw=="},"inclusionProof":{"logIndex":"3198211090","rootHash":"swr6E6jo6mgHiQsmLQo5aL0Zg7AHvymbhk5DXAwEhjs=","treeSize":"3198211093","hashes":["9PbjhJpbzOyTCV/sEPyPFgeH/qjHJbuW7QH8gk6kR80=","6JDYFkp8auDjFB3Q5uYN5BDjVhhSAFaEGG6EgY9G+y4=","rxRFZI6+SVYYSLMe2v/ZEQY3jSSHDHrrkXGV3NbUBHE=","pIoqlc07t890YWfAcHm0fNtFT6km/LSaO1eJqMe3xBU=","NvhAA1+LqtXvaowiFXcolXI/TyFO3CsufLfJu3VJv2k=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211093\nswr6E6jo6mgHiQsmLQo5aL0Zg7AHvymbhk5DXAwEhjs=\n\n— rekor.sigstore.dev wNI9ajBFAiAq/PwmXU3ZFaonMFSB8d/ossgWo2K118npHdR8A/mLngIhAJCXg9f9+Y8+UAs1rSQ7dfKRtnf7ro9SXqfzdqm29QHJ\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQg+NTKOCMpoQRBjI+mKg3OUpNHB9nAxu6WfXvu+lrCLz8CFQDob5vBjoqaxylhdDzWcd+IAONEsRgPMjAyNjEwMTkxMTA2MzRaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHaMIIB1gIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTExMDYzNFowLwYJKoZIhvcNAQkEMSIEIFOscmhyYjXcNsGYlIOFQVTz0GiEWanARkc8Lg6hMmndMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRmMGQCME4T3U6YCN+QmclfnyXK64eVHoybayuk8dEQgCslB7yd8Q7OTjrnk0sTX3uyBTjW8AIwb1Cfu+b3G6UTsIZrMgSu4AWXvZXVbAcWf+RkqUVOu/PPPR6otdMy/G4NsIhyo2pI"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"+z1HUvsKOHrQqRSM7aNulk15k0hitolsZNnipqdS6FM="},"signature":"MEUCIF9kQ0x8CJmIvsSxCYa71MSjT8nrHiNHxd2x3gOM+oS8AiEAmACATEVcsm+xDWR9m+ilfQ+jo27a3Dxa0PcoPlWhaGw="}} \ No newline at end of file diff --git a/build/torch214-cu126-aarch64-linux/symbols.json b/build/torch214-cu126-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch214-cu126-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch214-cu130-aarch64-linux/__init__.py b/build/torch214-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/__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"] diff --git a/build/torch214-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch214-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..1920be60e45245bd8504a28f0a4262e0e89427d7 --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:28b0c05e06102f2146f345c82b3148e7c44ca1c51ded30a2befcd3a4cd11e20c +size 9846472 diff --git a/build/torch214-cu130-aarch64-linux/_ops.py b/build/torch214-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch214-cu130-aarch64-linux/layers.py b/build/torch214-cu130-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/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"] diff --git a/build/torch214-cu130-aarch64-linux/metadata.json b/build/torch214-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..241a9cdb28afab8dc233943f9b4bfd9035babdba --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "KLDAXgYQLyFG80XIKzFI58RMocUd7TCivvzTpM0R4gw=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch214-cu130-aarch64-linux/metadata.json.sigstore b/build/torch214-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..870d0e705da8c3c2e469001d6d5a3658dbf8c79a --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115367","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407995","inclusionPromise":{"signedEntryTimestamp":"MEYCIQDfnhTH7118iPWQ68hWz8FkfyxRAfoyTuJV2Pxb0ZJLRAIhAJcv1IiNPwZ8zg0c+LgSpveal1xZ1/YdngBTgN8xeH46"},"inclusionProof":{"logIndex":"3198211105","rootHash":"VWsPVyrZWi/e5Ao40/ENSwvLiaT2XFeeo/PGPZyY56Q=","treeSize":"3198211108","hashes":["+0eCo5XgBf8ySsV7Bw+YndSGEnUbFv1yVINSGxl+eT8=","lijOnTUw70OX44BDuguKYgQdhE4uurL4eZA1n+Dxn+M=","SS3Vp2zM5t/UhDa3fi0Ix6rRIALVacp1UVn9tvW97h8=","NvhAA1+LqtXvaowiFXcolXI/TyFO3CsufLfJu3VJv2k=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211108\nVWsPVyrZWi/e5Ao40/ENSwvLiaT2XFeeo/PGPZyY56Q=\n\n— rekor.sigstore.dev wNI9ajBEAiBQYlHs0+t3tbZER1JXwg1CAVBmJpgbDmDS3c30cPc2PwIgYIqFFu6p+pB9dD69ZgaZ0OuFyMT1+kWPvcg2eaLLXnk=\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgObw7CFn/lfEaqlr+DnD8GM1SL6sx1sMLzofNAOLkaeICFQDluVuJBfjpqQtVEqiqIaMSQkHPoRgPMjAyNjEwMTkxMTA2MzVaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTExMDYzNVowLwYJKoZIhvcNAQkEMSIEIORNuFdwpjwGyflm2pxDahTK6nY7tHIT4LVFp0f8Sb04MIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMQCBvUGoDrSfRjVC67YgmWxryywirQV58SxCutFFypvq1xdlHl5E96yNWA9KdsjblE8CMFumVn6AvDy7/sQ7cNOlnbL6k/mV1t+Vt/F0IS6lLlnBG3SUcncmObm+C+GKqFSDOg=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"/0FtN/fsIUfO0x13n17Ua7G66iIUWKfGs3fsyFuDSH0="},"signature":"MEQCIBcDxre+JumzoPNo7tg4xXqrF+hPhFqgBFQsY0tJDikjAiB2fXpkm/oakBBdDCBGlTgTf/Yyf+GGUfTCIJeJr09oww=="}} \ No newline at end of file diff --git a/build/torch214-cu130-aarch64-linux/symbols.json b/build/torch214-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch214-cu130-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch214-cu132-aarch64-linux/__init__.py b/build/torch214-cu132-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/__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"] diff --git a/build/torch214-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch214-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..27a903a7eb7ebd530befc83df6bab65e10ee1955 --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:db6db7938b4aa62027ebdbb98907ad0a2fec273f61d878beb6e00b6f056554f9 +size 9980320 diff --git a/build/torch214-cu132-aarch64-linux/_ops.py b/build/torch214-cu132-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch214-cu132-aarch64-linux/layers.py b/build/torch214-cu132-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/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"] diff --git a/build/torch214-cu132-aarch64-linux/metadata.json b/build/torch214-cu132-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6cd81725d99cb4ff0c8424ff26153d31d8d03701 --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "2223k4tKpiAn69u5iQetCi/sJz9h2Hi+tuALbwVlVPk=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch214-cu132-aarch64-linux/metadata.json.sigstore b/build/torch214-cu132-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..4531772805ccc9798df3d6bd3aead9e7b42b0c6f --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115385","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407996","inclusionPromise":{"signedEntryTimestamp":"MEYCIQDxBqXHMVoOCGZ6F8SDFfFQSyYHUt62K+Tfp+wVScns8wIhALAgnv6ID9K2v9mTjGINRKltXhzyieeiIrnbQOCIGRKw"},"inclusionProof":{"logIndex":"3198211123","rootHash":"N3sZkHNQqVZLCp+tkk+aQvlEuPlHEjUhL0ut5+vyGsg=","treeSize":"3198211127","hashes":["3PXkHtjWFGqF1wQi1BVhwoNkuhUywzqdz9S0LxMFPN8=","FvwLT7RY+oKS4WxPm5wNerkBXhVOzYvKYZWYB7cz9Qg=","6DiwEEfTxqWTf3U5YtwWa6hy4ySwdrHnKtJ2ANhfFhw=","vCfB3SL5q/Rm/8Uz1GnrDnuhnvo79xdd9ClLcXHUrVI=","SS3Vp2zM5t/UhDa3fi0Ix6rRIALVacp1UVn9tvW97h8=","NvhAA1+LqtXvaowiFXcolXI/TyFO3CsufLfJu3VJv2k=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211127\nN3sZkHNQqVZLCp+tkk+aQvlEuPlHEjUhL0ut5+vyGsg=\n\n— rekor.sigstore.dev wNI9ajBEAiA9Sfbs1v4/W/Kml83v5t6jGeIXjly6Ind2cmfJPzPPggIgP+qMMYw6UapmPVhh5ndqtDRqLUu9Z8+5P9RPuVYWL4U=\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgUkgP7qAjITm3D36Pg3pTPZGuaKjfj16bXW5fP9ieLjsCFHPrdUBzGHqW0zLuDUqJrU9JInFpGA8yMDI2MTAxOTExMDYzNlowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTEwNjM2WjAvBgkqhkiG9w0BCQQxIgQgvE3qJfe6XDneCZ6NwgICfYnEtYu0JMSLjbyQtbCGy78wgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIxAMtQfjSLtrNmqmjNvslPptuu+d8FZH8OOjSIzu5ULP4508I3QOL5oMRu5OTLrp/M8gIwaIYNC8gQwYy7WwMMNvLeARwzAAUstY57xIbyj/rwGR58btzoTFUjdlFOs1hY+Mg3"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"3gMquCuX16lYayHe76x38R8LF9ReO2Gzm7iVe0y9ORU="},"signature":"MEUCICfigE+F96A28Rs/TWM/Onb2uigB+580+8KE7i7XSl5FAiEAzxADRTjxhqHJE4JIx0w1LqwYASiTT7WItQI487PZZq4="}} \ No newline at end of file diff --git a/build/torch214-cu132-aarch64-linux/symbols.json b/build/torch214-cu132-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch214-cu132-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch215-cu130-aarch64-linux/__init__.py b/build/torch215-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/__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"] diff --git a/build/torch215-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch215-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..74cb95abeff0c79b14fe5ae424a4b25045dc34aa --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:80af5d050ed631176f0f6a62220aa97e187b5ecc941d90afbed1d9f637846bd8 +size 9846472 diff --git a/build/torch215-cu130-aarch64-linux/_ops.py b/build/torch215-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch215-cu130-aarch64-linux/layers.py b/build/torch215-cu130-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/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"] diff --git a/build/torch215-cu130-aarch64-linux/metadata.json b/build/torch215-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3a9122d0677ba622f97d52ab38d103d51ce79bcc --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "gK9dBQ7WMRdvD2piIgqpfhh7XsyUHZCvvtHZ9jeEa9g=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch215-cu130-aarch64-linux/metadata.json.sigstore b/build/torch215-cu130-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..cb05b3cf45145641c75140ed0783998c8a106224 --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115399","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407997","inclusionPromise":{"signedEntryTimestamp":"MEQCIBrLEPlC+JA15PzG0n2QO7LUBlFlAsoKpjWp+14g1vQ7AiAw8YL8IJlyyqyNAeFihNzYZ8KmmnlksjS8lku5uwNesg=="},"inclusionProof":{"logIndex":"3198211137","rootHash":"qKyPpqWK8oC4hb7ixLvVKl5KSM3fiG02UUjF8zbDXO4=","treeSize":"3198211138","hashes":["QJZR0wRz9HegKrjxqS3ijo0SqkMiyK6kLOUPeaW4p6o=","7DKEtRdmdNHMEQvFqJybCImnYzu7q5SO7n7ofT36wSo=","NvhAA1+LqtXvaowiFXcolXI/TyFO3CsufLfJu3VJv2k=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211138\nqKyPpqWK8oC4hb7ixLvVKl5KSM3fiG02UUjF8zbDXO4=\n\n— rekor.sigstore.dev wNI9ajBGAiEAqt9qJCjM8wd1DSZpmNg2GbzNsW+/y4GP21v0g/n2B/0CIQDLZfBYZoGBQF7EH4rUrCndh/CrNWT7pk2SiYofuKogcw==\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgwGjYRlC8Z10m0HLaLXt3T0lR4eKopfENI3u+Gl9zl30CFDmwpXZavivWAygkSayA1ZG/v9kiGA8yMDI2MTAxOTExMDYzN1owAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTEwNjM3WjAvBgkqhkiG9w0BCQQxIgQgv4EJx3KlLMZ9D0cJk11O39XD28uenP5xEblbqC/7c5YwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIwCSrNsNBwtvHmj4gigeKXif8OSRMcpjPJvgttwAX+fQkES5bYzJwMW9f87bwCuJOyAjEAv5SOBxX9ee1FrXzpiid0E92pMzkRULAZRe6GJdbG8pPz2vBg4kMzhb5FAVWre5lt"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"DphaQODP65Pdkdg8BJ/WZ+1UL5RotQPHbftHTKG+fCI="},"signature":"MEYCIQDewSr9HumCZ44Ca83FjwcFuxpQKv2FICc07LpX7Jvk0QIhAPa4kV5JYvqTUhGHvUQr0Vcha5JiRZCB6wPn/XbgdYbY"}} \ No newline at end of file diff --git a/build/torch215-cu130-aarch64-linux/symbols.json b/build/torch215-cu130-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch215-cu130-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch215-cu132-aarch64-linux/__init__.py b/build/torch215-cu132-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/__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"] diff --git a/build/torch215-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch215-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..64b0440be09cfecf2689169bb5a1c8d46423a915 --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:96a86de5a7009dce88dccdcec90a9b0ac391538a6c74254da6f95b87af557dba +size 9980320 diff --git a/build/torch215-cu132-aarch64-linux/_ops.py b/build/torch215-cu132-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch215-cu132-aarch64-linux/layers.py b/build/torch215-cu132-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/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"] diff --git a/build/torch215-cu132-aarch64-linux/metadata.json b/build/torch215-cu132-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bd26df2df8d5fd1f01f15b40422df70491ed18b2 --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "lqht5acAnc6I3M3OyQqbCsORU4psdCVNpvlbh69Vfbo=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch215-cu132-aarch64-linux/metadata.json.sigstore b/build/torch215-cu132-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..76b5b19aca21c59b4dcd86447364c243f5eff305 --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115417","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407998","inclusionPromise":{"signedEntryTimestamp":"MEUCIQDgqoOMbVjTsj8dzbMFBfBU4ZFHqwVq7OW+BKUY0C0P2AIgHLeI0sKah4i0Zf/UBwtHvSD8mv0A1BjuUHjCFIdaEJw="},"inclusionProof":{"logIndex":"3198211155","rootHash":"KJFS2jrC/IFhP03Kj8BdMy389Y89pNDpw/ekvbDEzIw=","treeSize":"3198211168","hashes":["q8NN7KON/E6+ng/G43PNhHvgMHun7MoneCgO0FLyNLQ=","CQ1GAutr1VDXG3pUpY8cnR2vCVqiXcsCsHqqoOAu168=","b+gwuynDodRlt6Wz5/g3kLvv4A8BpiMKif5fZwAN2/I=","EJIfrVsPyLED7jOvnD91rkxMws47kSZzzviBj7tHeTE=","7MOS0cJmLwBXJbEUoy/hRlKTemmpJMRURBKKhFdADxc=","7DKEtRdmdNHMEQvFqJybCImnYzu7q5SO7n7ofT36wSo=","NvhAA1+LqtXvaowiFXcolXI/TyFO3CsufLfJu3VJv2k=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211168\nKJFS2jrC/IFhP03Kj8BdMy389Y89pNDpw/ekvbDEzIw=\n\n— rekor.sigstore.dev wNI9ajBFAiAZur6Fu2fWVyMBy5LpwLBd7a+cplbsTDFabgIR3lE7RwIhAJXqpqrBpA851GE9Fnf3rx896Y1NGMzW1FBdPyhLP9NX\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgoYVE8xyeL3R8tORybnQqaG1z6L3b2BD0n+6PEZZx48wCFQDnCZLeXfBCJn49NLbgIGQF6514eRgPMjAyNjEwMTkxMTA2MzdaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTExMDYzN1owLwYJKoZIhvcNAQkEMSIEIPnxp5+0WzdaDMUmmipBAioDDVtT2oplbFLZjEvxnrWDMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMQDBswiXIw/hzxCaiZl690hvgbF4gNcvMrLyOUWazu+qF20ZsC64AMFmTB5xohImcUkCMGXaEoTJ2yAo/34Ba5joELAxKKrVM1/sf4KcXLRnAYuHoa9rGZKNbyRDBti5OtxAMg=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"iACW9TKfHi+Ms9On5B1P2al6cxuX75N6+MyT/DB0MXY="},"signature":"MEQCIC7WLYhmpVy9aRdSoZFTbp3s5Ym02g+gq9vcSPp7CL59AiAOKyHZ7n4MeVs0IKKH3xtK8XgM1HxJvp8g6wO4rD/rYw=="}} \ No newline at end of file diff --git a/build/torch215-cu132-aarch64-linux/symbols.json b/build/torch215-cu132-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch215-cu132-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +} diff --git a/build/torch215-cu134-aarch64-linux/__init__.py b/build/torch215-cu134-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..33db73ca6e361af4707ba5bb5f55bf0e7c3005a4 --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/__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"] diff --git a/build/torch215-cu134-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so b/build/torch215-cu134-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..4cd2b73a71d26ee73cd1dcaa1ede58c6a06dc29e --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/_deformable_detr_cuda_fe2bb66.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5be47dcc1e063208aea4bacc16d891fe46e050ca86f48941f5ee424639aabc92 +size 9782640 diff --git a/build/torch215-cu134-aarch64-linux/_ops.py b/build/torch215-cu134-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bda990e7655149330868c4b80cfb6e2e85d116d --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _deformable_detr_cuda_fe2bb66 +ops = torch.ops._deformable_detr_cuda_fe2bb66 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_deformable_detr_cuda_fe2bb66::{op_name}" diff --git a/build/torch215-cu134-aarch64-linux/layers.py b/build/torch215-cu134-aarch64-linux/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..db94032dea3d445f27017f923ae80468e18d2d77 --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/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"] diff --git a/build/torch215-cu134-aarch64-linux/metadata.json b/build/torch215-cu134-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..2a2f7928904731300be7c958ebdd559561acf3cd --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/metadata.json @@ -0,0 +1,46 @@ +{ + "name": "deformable-detr", + "id": "_deformable_detr_cuda_fe2bb66", + "version": 1, + "kernels-minver": "0.14.0", + "license": "Apache-2.0", + "python-depends": [], + "kernel-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.3", + "11.0", + "12.0", + "12.1+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + }, + "digest": { + "algorithm": "sha256", + "files": { + "__init__.py": "/P9rmKjjgzhOqU3peSjUIi0u9GaxAmMEcaQb5kNGG90=", + "_deformable_detr_cuda_fe2bb66.abi3.so": "W+R9zB4GMgiupLrMFtiR/kbgUMqG9IlB9e5CRjmqvJI=", + "_ops.py": "i9uA2K4/sWeUF4FAwHQJ80J8tvwwaf5I4n6oN+q9VR4=", + "layers.py": "H3mypbDteagvzG5WTscmD05BfJhNbylbPJr0zb3k82A=", + "symbols.json": "SE1abIt8U28b3HcQzThCV+v19Ww2kNiQdWEjoQzsUpw=" + } + }, + "provenance": { + "kernel-builder": { + "version": "0.18.0-dev0", + "commit": "d054906a13710b811b96697b4635f03020842733", + "dirty": false + }, + "kernel": { + "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed", + "dirty": false + } + } +} \ No newline at end of file diff --git a/build/torch215-cu134-aarch64-linux/metadata.json.sigstore b/build/torch215-cu134-aarch64-linux/metadata.json.sigstore new file mode 100644 index 0000000000000000000000000000000000000000..1bcda82bcbe4a442c2e01017a73937cd2215246f --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/metadata.json.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"3320115456","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1792407999","inclusionPromise":{"signedEntryTimestamp":"MEUCIQD0WCbhAe+n9HEgizQoCyCVCBWNzMXmXheSz+C8s5rokQIgBBo9qaFE8gwwtx6HRgyiglYY6bqu99FEaj3Y5uk/dKw="},"inclusionProof":{"logIndex":"3198211194","rootHash":"XqZKh6l9Y0tOPsnJyhE/IdQcRcn1Vr2nrnCyZV3nzGc=","treeSize":"3198211200","hashes":["21urC2qiwMsqNV/Qm2RC7pBC0NK9JzsyfT+C6gle7NU=","x9KPfIy/CLphds7CRfsYdtVQ2YRtekhVVIilpkIRqvA=","NFpwU6Hwwg/61Mhgi/WZmcdtZNMSoNRbEbwXfEiX+pY=","55ocl85NjaL5/a6hpeKlSFtaoSgHWQtnZEX8+ut9mt8=","A2GqIkWMqVOkePHZwCheNitDu7hMjZZRi3ZisIVeDug=","sc9CtO7HdxAYz6PdbnvH5u7/7xmk0JHBukR1vdG39ds=","7DKEtRdmdNHMEQvFqJybCImnYzu7q5SO7n7ofT36wSo=","NvhAA1+LqtXvaowiFXcolXI/TyFO3CsufLfJu3VJv2k=","PJRsVvScXNHmqQge+wrG01cIyckZNEkkYLfYRFm0H14=","f4MktXqhBPk7ruDBxwgqTvXa7eCNzak9cUObXS0eTxI=","OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=","uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=","nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=","G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=","qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=","gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=","NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=","qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=","xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198211200\nXqZKh6l9Y0tOPsnJyhE/IdQcRcn1Vr2nrnCyZV3nzGc=\n\n— rekor.sigstore.dev wNI9ajBFAiAdO7bgsI046/7qQF+Y3G8VPjqNrOiCa7CNOqokHhsohgIhAMGtpYfSzaBg6HbHkqlXy1ripaGsBm6RW0l4DzRsURfJ\n"}},"canonicalizedBody":"eyJhcGlWZXJzaW9uIjoiMC4wLjEiLCJraW5kIjoiaGFzaGVkcmVrb3JkIiwic3BlYyI6eyJkYXRhIjp7Imhhc2giOnsiYWxnb3JpdGhtIjoic2hhMjU2IiwidmFsdWUiOiJkZDUyYThlODMwYjlkMWYxZDRhNDgzMmM5YmEwYTYyYjhmMzZhMTExZjY2YjA1NzNkZTFkNGQ2NDQwNWExYzVjIn19LCJzaWduYXR1cmUiOnsiY29udGVudCI6Ik1FUUNJSDNVVEhzUWMxcnNCM2F5ekhWYlBmV3czaG1zck1BQzVJanR6aXk1UXlnWUFpQlJtVnBmcGQ1U3E5bWlTcXNFYWtka0QrT0o0a05wU0FRNk1sZDRrNUtLREE9PSIsInB1YmxpY0tleSI6eyJjb250ZW50IjoiTFMwdExTMUNSVWRKVGlCRFJWSlVTVVpKUTBGVVJTMHRMUzB0Q2sxSlNVaE1WRU5EUW5KUFowRjNTVUpCWjBsVlMwcFZLM1V3ZEdKemVuazJOazU2U2tOSWRsbFNRWGt4VkdnMGQwTm5XVWxMYjFwSmVtb3dSVUYzVFhjS1RucEZWazFDVFVkQk1WVkZRMmhOVFdNeWJHNWpNMUoyWTIxVmRWcEhWakpOVWpSM1NFRlpSRlpSVVVSRmVGWjZZVmRrZW1SSE9YbGFVekZ3WW01U2JBcGpiVEZzV2tkc2FHUkhWWGRJYUdOT1RXcFplRTFFUlRWTlZFVjNUbXBOTkZkb1kwNU5hbGw0VFVSRk5VMVVSWGhPYWswMFYycEJRVTFHYTNkRmQxbElDa3R2V2tsNmFqQkRRVkZaU1V0dldrbDZhakJFUVZGalJGRm5RVVZaWXpsUVRXSmxXa2d3VHpVeVVqVjZWamhTUVZjM1IxTmxVV2xoZGtkRWJHUTBaVVFLVEZoNlFWbFhiSGhpZFRkYWNWcEpORlZ5YVhKRWFFZEtlR2xUVDNab0x6WnhNWEJvVW1GcFVHVm5ja1ZLT0RGU05YRlBRMEprU1hkbloxaFBUVUUwUndwQk1WVmtSSGRGUWk5M1VVVkJkMGxJWjBSQlZFSm5UbFpJVTFWRlJFUkJTMEpuWjNKQ1owVkdRbEZqUkVGNlFXWkNaMDVXU0ZOTlJVZEVRVmRuUWxSbUNqQXJibEJXYVZGU2JIWnRiekpQYTI5V1lVeEhUR2hvYTFCNlFuSkNaMDVXU0ZKRlFrRm1PRVZaVkVKbWFHd3hiMlJJVW5kamVtOTJUREprY0dSSGFERUtXV2sxYW1JeU1IWmhTRlp1V2pKc2RWb3lXbWhaTWxWMllUSldlV0p0Vm5OamVURnFZakl4ZEdSWE5YQmtTR3QyVEcxa2NHUkhhREZaYVRrellqTktjZ3BhYlhoMlpETk5kbGx1Vm5CaVIxRjFaVmRHZEdKRlFubGFWMXA2VERKb2JGbFhVbnBNTWpGb1lWYzBkMDlSV1V0TGQxbENRa0ZIUkhaNlFVSkJVVkZ5Q21GSVVqQmpTRTAyVEhrNU1HSXlkR3hpYVRWb1dUTlNjR0l5TlhwTWJXUndaRWRvTVZsdVZucGFXRXBxWWpJMU1GcFhOVEJNYlU1MllsUkJaa0puYjNJS1FtZEZSVUZaVHk5TlFVVkRRa0pHTTJJelNuSmFiWGgyWkRFNWEyRllUbmRaV0ZKcVlVUkJNa0puYjNKQ1owVkZRVmxQTDAxQlJVUkNRMmh0V2xSS2FRcFphbGt5V20xV2JFNXRUWGxaVkdNeldsZE9hbHBxUVRSWlZFRXhUVVJvYTFsNlZUTk9SRWswV2tSUk5FOUhWbXROUWsxSFEybHpSMEZSVVVKbk56aDNDa0ZSVVVWQ1ZVb3hZVmQ0YTAxRGMwZERhWE5IUVZGUlFtYzNPSGRCVVZWRlNGZG9NVm95WkhCaWJXUnRXVmRPYkV3eWRHeGpiVFZzWWtoTmRGa3lPWFFLWWxoV2RXRllValZOUWpCSFEybHpSMEZSVVVKbk56aDNRVkZaUlVRelNteGFiazEyWVVkV2FGcElUWFppVjBad1ltcEJOMEpuYjNKQ1owVkZRVmxQTHdwTlFVVkpRa013VFVzeWFEQmtTRUo2VDJrNGRtUkhPWEphVnpSMVdWZE9NR0ZYT1hWamVUVnVZVmhTYjJSWFNqRmpNbFo1V1RJNWRXUkhWblZrUXpWcUNtSXlNSGRpVVZsTFMzZFpRa0pCUjBSMmVrRkNRMUZTWmtSR01XOWtTRkozWTNwdmRrd3laSEJrUjJneFdXazFhbUl5TUhaaFNGWnVXakpzZFZveVdtZ0tXVEpWZG1FeVZubGliVlp6WTNreGFtSXlNWFJrVnpWd1pFaHJka3h0WkhCa1IyZ3hXV2s1TTJJelNuSmFiWGgyWkROTmRsbHVWbkJpUjFGMVpWZEdkQXBpUlVKNVdsZGFla3d5YUd4WlYxSjZUREl4YUdGWE5IZFBRVmxMUzNkWlFrSkJSMFIyZWtGQ1EyZFJjVVJEYUcxYVZFcHBXV3BaTWxwdFZteE9iVTE1Q2xsVVl6TmFWMDVxV21wQk5GbFVRVEZOUkdocldYcFZNMDVFU1RSYVJGRTBUMGRXYTAxQ2MwZERhWE5IUVZGUlFtYzNPSGRCVVhORlJGRjNUR015Vm5NS1dta3hiMkl6VGpCYVYxRjNVVUZaUzB0M1dVSkNRVWRFZG5wQlFrUkJVWGxFUkVKdlpFaFNkMk42YjNaTU1tUndaRWRvTVZscE5XcGlNakIyWVVoV2JncGFNbXgxV2pKYWFGa3lWWFpoTWxaNVltMVdjMk41TVdwaU1qRjBaRmMxY0dSSWEzZFBRVmxMUzNkWlFrSkJSMFIyZWtGQ1JGRlJjVVJEYUcxYVZFcHBDbGxxV1RKYWJWWnNUbTFOZVZsVVl6TmFWMDVxV21wQk5GbFVRVEZOUkdocldYcFZNMDVFU1RSYVJGRTBUMGRXYTAxQ09FZERhWE5IUVZGUlFtYzNPSGNLUVZFMFJVVlJkMUJqYlZadFkzazViMXBYUm10amVUbDBXVmRzZFUxQ2IwZERhWE5IUVZGUlFtYzNPSGRCVVRoRlJFRjNTMDFVUVROTlZGRXpUbFJWZVFwUFZFRjFRbWR2Y2tKblJVVkJXVTh2VFVGRlVVSkRRVTFJYldnd1pFaENlazlwT0haYU1td3dZVWhXYVV4dFRuWmlVemx2WkZka2JtRlhOVzVhYlVacUNscFVRVmxDWjI5eVFtZEZSVUZaVHk5TlFVVlNRa0Z2VFVORVNURk9la2wzVG5wUmVrMUhNRWREYVhOSFFWRlJRbWMzT0hkQlVrbEZXSGQ0WkdGSVVqQUtZMGhOTmt4NU9XNWhXRkp2WkZkSmRWa3lPWFJNTW1neFdqSmtjR0p0WkcxWlYwNXNUREowYkdOdE5XeGlTRTEwV1RJNWRHSllWblZoV0ZJMVRIazFiZ3BoV0ZKdlpGZEpkbVF5T1hsaE1scHpZak5rZWt3eVNqRmhWM2hyVEc1c2FHSlhlRUZqYlZadFkzazViMXBYUm10amVUbDBXVmRzZFUxRVowZERhWE5IQ2tGUlVVSm5OemgzUVZKTlJVdG5kMjlhYlZWNVdXMUpNazV0V214YVZGcHFUVzFGTTA0eVZtcFpNbGwzVDBkRmQwNVVRVFJhUjAweFRucFJlVTlIVVRBS1QwUm9iRnBFUVdoQ1oyOXlRbWRGUlVGWlR5OU5RVVZWUWtKTlRVVllaSFpqYlhSdFlrYzVNMWd5VW5Cak0wSm9aRWRPYjAxSFVVZERhWE5IUVZGUlFncG5OemgzUVZKVlJWWm5lRlZoU0ZJd1kwaE5Oa3g1T1c1aFdGSnZaRmRKZFZreU9YUk1NbWd4V2pKa2NHSnRaRzFaVjA1c1RESjBiR050Tld4aVNFMTBDbGt5T1hSaVdGWjFZVmhTTlV3eVJtcGtSMngyWW01TmRtTnVWblZqZVRoNlQxUkplazlVVlhwT2VtTXdUbWs1YUdSSVVteGlXRUl3WTNrNGVFMUNXVWNLUTJselIwRlJVVUpuTnpoM1FWSlpSVU5CZDBkalNGWnBZa2RzYWsxRldVZERhWE5IUVZGUlFtYzNPSGRCVW1kRlQwRjNNbU50Vm5kaWVuQnZaRmRrYmdwaFZ6VnVXbTFHYWxwVE9YSmFXRXAxV2xkNGVreFhUblppVnpFeFltMXNNR1ZVY0hsYVYxazJZMjFXYldONU9XOWFWMFpyWTNrNWRGbFhiSFZOU1VkTUNrSm5iM0pDWjBWRlFXUmFOVUZuVVVOQ1NEQkZaWGRDTlVGSVkwRXpWREIzWVhOaVNFVlVTbXBIVWpSamJWZGpNMEZ4U2t0WWNtcGxVRXN6TDJnMGNIa0taME00Y0Rkdk5FRkJRVWRvVlRsbFVsTlJRVUZDUVUxQlUwUkNSMEZwUlVGc1EwOXZWMVJYWVZSQ1VqbEVTbEZVWm5sRlp6RXJPVmQ2WkZObGJsRjZlQXBuZVhoVVNtNVZWa2RqWjBOSlVVUndaM1ZTY2xSRVZIcDJLMU5rUnl0R1ZVeFdSWEZaZEZoWFdXdFllRmxNUVVseU1tTmtUM2RXWTBGVVFVdENaMmR4Q21ocmFrOVFVVkZFUVhkT2IwRkVRbXhCYWtWQmRUUlVLMEZvUjJSa1J6aFBiRzlXVEc1V04yMHhWV0l2Y0V4MlZGVTVlRUpvUkhneFdVcEVaV3g0WkcwS01sZFZTMVJNVjFnNE1uUkRRVlZaY0ROdVYxcEJha0pxWm5KRVIwVjRWR2h0TmpKQ2RqQklZa0pJWlRKM1lUVnBURnBNYkVFMU5WZGlhVEZXY1ZoelJ3cFJWR05PUzJ0T1NHUnVWME42YmxCc05YZENWMHBuV1QwS0xTMHRMUzFGVGtRZ1EwVlNWRWxHU1VOQlZFVXRMUzB0TFFvPSJ9fX19"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgFaU2HEiB568IiF5EdsTQAHpNqSnhXwdkhpXo06RFE4oCFQDDIY1HPZEuZJgrJiqTHTUoQaAayRgPMjAyNjEwMTkxMTA2MzhaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHaMIIB1gIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MTAxOTExMDYzOFowLwYJKoZIhvcNAQkEMSIEIIRwu3T1AAPFS9hcWY6QSMRiB1ine8uWxpEbPYtXOh6rMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRmMGQCMDppeT0FPC8MF0Chayaz3i37d3KL+2lkm7qLmwebPD1XWE496bF1WymhPmYuUJh+lwIwIAGaYRTk2YQmYiVfNFQD48fvSI4Q3hY/snlh1Alby18VlsmsMO4j1sSprbH9d6b/"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"3VKo6DC50fHUpIMsm6CmK482oRH2awVz3h1NZEBaHFw="},"signature":"MEQCIH3UTHsQc1rsB3ayzHVbPfWw3hmsrMAC5Ijtziy5QygYAiBRmVpfpd5Sq9miSqsEakdkD+OJ4kNpSAQ6Mld4k5KKDA=="}} \ No newline at end of file diff --git a/build/torch215-cu134-aarch64-linux/symbols.json b/build/torch215-cu134-aarch64-linux/symbols.json new file mode 100644 index 0000000000000000000000000000000000000000..8d0c03c4e45c906aca68511fa4a3a022eea92afa --- /dev/null +++ b/build/torch215-cu134-aarch64-linux/symbols.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "module": "_deformable_detr_cuda_fe2bb66", + "functions": [ + { + "name": "ms_deform_attn_forward", + "qualname": "ms_deform_attn_forward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "torch.Tensor" + } + }, + { + "name": "ms_deform_attn_backward", + "qualname": "ms_deform_attn_backward", + "module": "_deformable_detr_cuda_fe2bb66", + "kind": "function", + "doc": null, + "signature": { + "parameters": [ + { + "name": "value", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "spatial_shapes", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "level_start_index", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "sampling_loc", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "attn_weight", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "grad_output", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "torch.Tensor" + }, + { + "name": "im2col_step", + "kind": "POSITIONAL_OR_KEYWORD", + "default": null, + "annotation": "int" + } + ], + "return_annotation": "List[torch.Tensor]" + } + } + ], + "layers": [ + { + "name": "MultiScaleDeformableAttention", + "qualname": "MultiScaleDeformableAttention", + "module": "_deformable_detr_cuda_fe2bb66.layers", + "kind": "class", + "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n import torch.nn as nn\n import torch.nn.functional as F\n\n\n class Model(nn.Module):\n def __init__(self) -> None:\n super().__init__()\n self.conv1 = nn.Conv2d(1, 20, 5)\n self.conv2 = nn.Conv2d(20, 20, 5)\n\n def forward(self, x):\n x = F.relu(self.conv1(x))\n return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n As per the example above, an ``__init__()`` call to the parent class\n must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n evaluation mode.\n:vartype training: bool", + "signature": { + "parameters": [ + { + "name": "args", + "kind": "VAR_POSITIONAL", + "default": null, + "annotation": "Any" + }, + { + "name": "kwargs", + "kind": "VAR_KEYWORD", + "default": null, + "annotation": "Any" + } + ], + "return_annotation": "None" + }, + "attributes": { + "has_backward": null, + "can_torch_compile": null + } + } + ] +}