SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2010.04159 · ICLR · 2021

Deformable DETR: Deformable Transformers for End-to-End Object Detection

Weijie Su, Xizhou Zhu, Lewei Lu, Bin Li, Xiaogang Wang, Jifeng Dai

arXiv · PDF · Open in the Atlas

Code that ran

37 of 55 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (9 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 3 violated it and 18 have no contract verdict; 14 failures of our instrument; 18 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2010.04159.json · badge: /api/ran/2010.04159.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
Cedric-Perauer/Deformable_Detr_PIL community (classifier label)
classifier basis not recorded on the link
7 ran · 0 no recorded run
LONGXUANX/CDFormer_code community
Papers with Code archive
5 ran · 3 no recorded run
Visual-Behavior/aloception community
Papers with Code archive
4 ran · 8 no recorded run
duongnv0499/Explain-Deformable-DETR community
Papers with Code archive
4 ran · 0 no recorded run
lyqcom/detr community (classifier label)
classifier basis not recorded on the link
4 ran · 0 no recorded run
YC-Lai/Sequential-DDETR community
Papers with Code archive
3 ran · 3 no recorded run
roboflow/rf-detr community
Papers with Code archive
3 ran · 1 no recorded run
zhechen/deformable-detr-rego community
Papers with Code archive
2 ran · 1 no recorded run
dianzl/sodformer community
Papers with Code archive
2 ran · 0 no recorded run
hanouticelina/deformable-DETR reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
haoy945/demf community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
gokulkarthik/deformable-detr community
Papers with Code archive
0 ran · 1 no recorded run
ver0z/Deformable-DETR- community
Papers with Code archive
0 ran · 1 no recorded run
FunctionStatusWhere it lives
DeformableDETR Ran
ran on a synthesized input · constructed an object; no result was computed
dianzl/sodformer/models/deformable_detr.py
pointer only (licence: NONE) · get_code("eff6751dedaae05e")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, dianzl/sodformer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

DeformableDETR Ran
ran on a synthesized input · constructed an object; no result was computed
duongnv0499/Explain-Deformable-DETR/models/deformable_detr.py
code served (permissive licence) · get_code("50c3542b65114a72")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, DeformableDETR: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import math

torch.manual_seed(0)

# Minimal backbone class
class MinimalBackbone(nn.Module):
    def __init__(self):
        super().__init__()
        self.strides = [8, 16, 32]
        self.num_channels = [64, 128, 256]
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)
        self.conv3 = nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1)
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        return x

# Minimal transformer class
class MinimalTransformer(nn.Module):
    def __init__(self, d_model=256, nhead=8, num_encoder_layers=6, num_decoder_layers=6):
        super().__init__()
        self.d_model = d_model
        self.nhead = nhead
        encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead, batch_first=True)
        self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_encoder_layers)
        decoder_layer = nn.TransformerDecoderLayer(d_model=d_model, nhead=nhead, batch_first=True)
        self.decoder = nn.TransformerDecoder(decoder_layer, num_layers=num_decoder_layers)
    
    def forward(self, src, query_embed, pos_embed=None, mask=None):
        if pos_embed is not None:
            src = src + pos_embed
        memory = self.encoder(src, src_key_padding_mask=mask)
        query = query_embed.unsqueeze(0).expand(src.shape[0], -1, -1)
        hs = self.decoder(query, memory)
        return hs

# Create instances
backbone = MinimalBackbone()
transformer = MinimalTransformer(d_model=256, nhead=8, num_encoder_layers=2, num_decoder_layers=2)
num_classes = 91
num_queries = 100
num_feature_levels = 3
aux_loss = True
with_box_refine = False
two_stage = False

ARGS = {
    'backbone': backbone,
    'transformer': transformer,
    'num_classes': num_classes,
    'num_queries': num_queries,
    'num_feature_levels': num_feature_levels,
    'aux_loss': aux_loss,
    'with_box_refine': with_box_refine,
    'two_stage': two_stage,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DeformableDETR — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DeformableDETR output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
DeformableDETR Ran
ran on a synthesized input · constructed an object; no result was computed
hanouticelina/deformable-DETR/models/deformable_detr.py
code served (permissive licence) · get_code("edf20b8faa459a2e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, DeformableDETR: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import math

torch.manual_seed(0)

# Define a minimal backbone that provides the required attributes
class SimpleBackbone(nn.Module):
    def __init__(self):
        super().__init__()
        self.num_channels = [64, 128, 256]  # channels for each feature level
        self.strides = [8, 16, 32]  # strides for each feature level
    
    def forward(self, x):
        # Return multi-scale features
        features = []
        features.append(torch.randn(2, 64, 32, 32))
        features.append(torch.randn(2, 128, 16, 16))
        features.append(torch.randn(2, 256, 8, 8))
        return features

# Define a minimal transformer that provides required attributes and methods
class SimpleDecoder(nn.Module):
    def __init__(self, d_model):
        super().__init__()
        self.num_layers = 6
        self.bbox_pred = None
    
    def forward(self, x, query_embed):
        return x

class SimpleTransformer(nn.Module):
    def __init__(self, d_model=256):
        super().__init__()
        self.C = d_model
        self.decoder = SimpleDecoder(d_model)
    
    def forward(self, features, query_embed, masks):
        return self.decoder(features, query_embed)

# Create instances
backbone = SimpleBackbone()
transformer = SimpleTransformer(d_model=256)

ARGS = {
    'backbone': backbone,
    'transformer': transformer,
    'num_classes': 80,
    'num_queries': 300,
    'num_feature_levels': 4,
    'aux_loss': False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DeformableDETR — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DeformableDETR output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
DeformableTransformerEncoder Ran
ran on a synthesized input · constructed an object; no result was computed
LONGXUANX/CDFormer_code/models/deformable_transformer.py
code served (permissive licence) · get_code("963474a60c239350")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, DeformableTransformerEncoder: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a minimal encoder layer that satisfies the interface
class MockEncoderLayer(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, src, pos, reference_points, spatial_shapes, level_start_index, padding_mask, category_code, tsp, supp_class_id):
        # Process input and return modified output
        output = self.linear(src)
        return output
    
    def forward_supp_branch(self, src, pos, reference_points, spatial_shapes, level_start_index, padding_mask, tsp, support_boxes, supp_class_id):
        # Return output and a category code
        output = self.linear(src)
        category_code = torch.randn(2, 4)  # batch_size=2, dim=4
        return output, category_code

# Create encoder layers
num_layers = 2
encoder_layers = [MockEncoderLayer() for _ in range(num_layers)]

# Create tensors with distinct sizes for different dimensions
batch_size = 2
hidden_dim = 4
sequence_length = 12  # 3x4 spatial = 12 positions
num_spatial_levels = 2

src = torch.randn(sequence_length, batch_size, hidden_dim)
pos = torch.randn(sequence_length, batch_size, hidden_dim)

# spatial_shapes: list of (H, W) for each level - use 3 and 4 for distinction
spatial_shapes = [(3, 4), (2, 3)]

# level_start_index: cumulative sum of spatial sizes
level_start_index = torch.tensor([0, 12, 18], dtype=torch.long)

# valid_ratios: [batch_size, num_levels, 2]
valid_ratios = torch.ones(batch_size, num_spatial_levels, 2)

# padding_mask: [batch_size, sequence_length]
padding_mask = torch.zeros(batch_size, sequence_length, dtype=torch.bool)

# category_codes: list of codes, one per layer
category_codes = [torch.randn(batch_size, hidden_dim) for _ in range(num_layers)]

# tsp: some kind of parameter, create a simple tensor
tsp = torch.randn(batch_size, hidden_dim)

# supp_class_id: support class id
supp_class_id = torch.tensor([0, 1], dtype=torch.long)

ARGS = {
    'encoder_layers': encoder_layers,
    'num_layers': num_layers,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DeformableTransformerEncoder — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DeformableTransformerEncoder output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
DeformableTransformerEncoder Ran
ran on a synthesized input
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("7e36b0b69432a072")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

InputProj Ran
ran on a synthesized input
YC-Lai/Sequential-DDETR/models/deformable_detr.py
code served (permissive licence) · get_code("f5d48d6ab75ae394")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from torch import Tensor
from typing import Optional

# Mock position embedding module
class MockPositionEmbedding(nn.Module):
    def __init__(self, hidden_dim):
        super().__init__()
        self.hidden_dim = hidden_dim
        self.linear = nn.Linear(hidden_dim, hidden_dim)
    
    def forward(self, nested_tensor):
        src, mask = nested_tensor.decompose()
        # Return positional embedding with same shape as src
        return self.linear(src.flatten(2).transpose(1, 2)).transpose(1, 2).view_as(src)

# NestedTensor class (from the provided code)
class NestedTensor(object):
    def __init__(self, tensors, mask: Optional[Tensor]):
        self.tensors = tensors
        self.mask = mask

    def to(self, device, non_blocking=False):
        cast_tensor = self.tensors.to(device, non_blocking=non_blocking)
        mask = self.mask
        if mask is not None:
            assert mask is not None
            cast_mask = mask.to(device, non_blocking=non_blocking)
        else:
            cast_mask = None
        return NestedTensor(cast_tensor, cast_mask)

    def record_stream(self, *args, **kwargs):
        self.tensors.record_stream(*args, **kwargs)
        if self.mask is not None:
            self.mask.record_stream(*args, **kwargs)

    def decompose(self):
        return (self.tensors, self.mask)

    def __repr__(self):
        return str(self.tensors)

# InputProj class (from the provided code)
class InputProj(nn.Module):
    """ This is the Input projection module for Sequential DDETR """

    def __init__(self, position_embedding, num_feature_levels, backbone_strides, backbone_num_channels, hidden_dim):
        super().__init__()
        self.num_feature_levels = num_feature_levels
        if num_feature_levels > 1:
            num_backbone_outs = len(backbone_strides)
            input_proj_list = []
            for _ in range(num_backbone_outs):
                in_channels = backbone_num_channels[_]
                input_proj_list.append(nn.Sequential(nn.Conv2d(in_channels, hidden_dim, kernel_size=1), nn.GroupNorm(32, hidden_dim)))
            for _ in range(num_feature_levels - num_backbone_outs):
                input_proj_list.append(nn.Sequential(nn.Conv2d(in_channels, hidden_dim, kernel_size=3, stride=2, padding=1), nn.GroupNorm(32, hidden_dim)))
                in_channels = hidden_dim
            self.input_proj = nn.ModuleList(input_proj_list)
        else:
            self.input_proj = nn.ModuleList([nn.Sequential(nn.Conv2d(backbone_num_channels[0], hidden_dim, kernel_size=1), nn.GroupNorm(32, hidden_dim))])
        self.position_embedding = position_embedding
        for proj in self.input_proj:
            nn.init.xavier_uniform_(proj[0].weight, gain=1)
            nn.init.constant_(proj[0].bias, 0)

    def forward(self, features: list, pos: list, sample_mask: torch.tensor):
        import torch.nn.functional as F
        srcs = []
        masks = []
        for l, feat in enumerate(features):
            src, mask = feat.decompose()
            srcs.append(self.input_proj[l](src))
            masks.append(mask)
            assert mask is not None
        if self.num_feature_levels > len(srcs):
            _len_srcs = len(srcs)
            for l in range(_len_srcs, self.num_feature_levels):
                if l == _len_srcs:
                    src = self.input_proj[l](features[-1].tensors)
                else:
                    src = self.input_proj[l](srcs[-1])
                m = sample_mask
                mask = F.interpolate(m[None].float(), size=src.shape[-2:]).to(torch.bool)[0]
                pos_l = self.position_embedding(NestedTensor(src, mask)).to(src.dtype)
                srcs.append(src)
                masks.append(mask)
                pos.append(pos_l)
        out_pos = pos
        return (srcs, masks, out_pos)

# Setup arguments
INIT_ARGS = {
    'position_embedding': MockPositionEmbedding(hidden_dim=64),
    'num_feature_levels': 2,
    'backbone_strides': [8, 16],
    'backbone_num_channels': [32, 48],
    'hidden_dim': 64,
}

ARGS = {
    'features': [
        NestedTensor(torch.randn(2, 32, 16, 20), torch.ones(2, 16, 20, dtype=torch.bool)),
        NestedTensor(torch.randn(2, 48, 8, 10), torch.ones(2, 8, 10, dtype=torch.bool)),
    ],
    'pos': [
        torch.randn(2, 64, 16, 20),
        torch.randn(2, 64, 8, 10),
    ],
    'sample_mask': torch.ones(2, 16, 20, dtype=torch.bool),
}

# Construct and call
if __name__ == '__main__':
    model = InputProj(**INIT_ARGS)
    output = model(**ARGS)
    print("Output types:", type(output[0]), type(output[1]), type(output[2]))
    print("Number of sources:", len(output[0]))
    print("Number of masks:", len(output[1]))
    print("Number of positions:", len(output[2]))
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
MHAttentionMap Ran
ran on a synthesized input · constructed an object; no result was computed
YC-Lai/Sequential-DDETR/models/deformable_detr.py
code served (permissive licence) · get_code("e622cf29b035c908")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MHAttentionMap: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(0)

class MHAttentionMap(nn.Module):
    """This is a 2D attention module, which only returns the attention softmax (no multiplication by value)"""

    def __init__(self, query_dim, hidden_dim, num_heads, dropout=0, bias=True):
        super().__init__()
        self.num_heads = num_heads
        self.hidden_dim = hidden_dim
        self.dropout = nn.Dropout(dropout)
        self.q_linear = nn.Linear(query_dim, hidden_dim, bias=bias)
        self.k_linear = nn.Linear(query_dim, hidden_dim, bias=bias)
        nn.init.zeros_(self.k_linear.bias)
        nn.init.zeros_(self.q_linear.bias)
        nn.init.xavier_uniform_(self.k_linear.weight)
        nn.init.xavier_uniform_(self.q_linear.weight)
        self.normalize_fact = float(hidden_dim / self.num_heads) ** (-0.5)

    def forward(self, q, k, mask=None):
        """
        :param q                       (bs, n_query, d_model)
        :param k                       (bs, d_model, h, w)
        :param mask                    (h, w)
        """
        q = self.q_linear(q)
        k = F.conv2d(k, self.k_linear.weight.unsqueeze(-1).unsqueeze(-1), self.k_linear.bias)
        qh = q.view(q.shape[0], q.shape[1], self.num_heads, self.hidden_dim // self.num_heads)
        kh = k.view(k.shape[0], self.num_heads, self.hidden_dim // self.num_heads, k.shape[-2], k.shape[-1])
        weights = torch.einsum('bqnc,bnchw->bqnhw', qh * self.normalize_fact, kh)
        if mask is not None:
            weights.masked_fill_(mask.unsqueeze(1).unsqueeze(1), float('-inf'))
        weights = F.softmax(weights.flatten(2), dim=-1).view_as(weights)
        weights = self.dropout(weights)
        return weights


# Create the module instance
query_dim = 4
hidden_dim = 8
num_heads = 2
dropout = 0.1
bias = True

attention_module = MHAttentionMap(
    query_dim=query_dim,
    hidden_dim=hidden_dim,
    num_heads=num_heads,
    dropout=dropout,
    bias=bias
)

# Create inputs for forward pass
batch_size = 2
n_query = 3
h, w = 5, 6

# q shape: (bs, n_query, query_dim)
q = torch.randn(batch_size, n_query, query_dim)

# k shape: (bs, query_dim, h, w) - note k uses query_dim as channel dimension
k = torch.randn(batch_size, query_dim, h, w)

# mask shape: (h, w)
mask = torch.zeros(h, w, dtype=torch.bool)

ARGS = {
    "query_dim": query_dim,
    "hidden_dim": hidden_dim,
    "num_heads": num_heads,
    "dropout": dropout,
    "bias": bias,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MHAttentionMap — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MHAttentionMap output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MLP Ran
ran on a synthesized input · constructed an object; no result was computed
duongnv0499/Explain-Deformable-DETR/models/deformable_detr.py
code served (permissive licence) · get_code("79f40d31f6868f07")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MLP: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    'input_dim': 4,
    'hidden_dim': 8,
    'output_dim': 3,
    'num_layers': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MLP — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MLP output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MLP Ran
ran on a synthesized input · constructed an object; no result was computed
hanouticelina/deformable-DETR/models/deformable_detr.py
code served (permissive licence) · get_code("e4210f43cf8be779")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MLP: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    "input_dim": 4,
    "hidden_dim": 8,
    "output_dim": 3,
    "num_layers": 3,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MLP — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MLP output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
NestedTensor Ran
ran on a synthesized input · constructed an object; no result was computed
duongnv0499/Explain-Deformable-DETR/models/deformable_detr.py
code served (permissive licence) · get_code("a0958f4fe260b7bf")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, NestedTensor: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from typing import Optional

torch.manual_seed(0)

# Create a simple tensor for the NestedTensor
tensors = torch.randn(2, 4)

# Create an optional mask tensor (same shape as tensors)
mask = torch.randn(2, 4)

ARGS = {
    "tensors": tensors,
    "mask": mask
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type NestedTensor — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a NestedTensor output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
NestedTensor Ran
ran on a synthesized input
zhechen/deformable-detr-rego/models/deformable_detr.py
code served (permissive licence) · get_code("6e981ab142d64bc6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from typing import Optional, List, Tuple

# INIT_ARGS for NestedTensor
INIT_ARGS = {
    "tensors": torch.randn(2, 4, 3, 5),  # batch=2, feature_dim=4, H=3, W=5
    "mask": torch.randint(0, 2, (2, 3, 5)).bool(),  # batch=2, H=3, W=5
    "im_shapes": [(3, 5), (3, 5)]  # List of (H, W) for each item in batch
}

# ARGS for calling the instance (no explicit method, uses __repr__ or decompose)
# Since NestedTensor is not an nn.Module, we'll call decompose() to demonstrate computation
METHOD = 'decompose'
ARGS = {}  # decompose() takes no arguments
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
ScaledDotProductAttention Ran
ran on a synthesized input · constructed an object; no result was computed
LONGXUANX/CDFormer_code/models/deformable_transformer.py
code served (permissive licence) · get_code("a290e690b43e24ae")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, ScaledDotProductAttention: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(0)

# Create tiny tensors for the forward pass
batch_size = 2
seq_len_q = 3
seq_len_k = 3
d_model = 4

q = torch.randn(batch_size, seq_len_q, d_model)
k = torch.randn(batch_size, seq_len_k, d_model)
v = torch.randn(batch_size, seq_len_k, d_model)

# Define the arguments dict for ScaledDotProductAttention.__init__
ARGS = {
    'temperature': 2.0,
    'attn_dropout': 0.1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ScaledDotProductAttention — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ScaledDotProductAttention output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
SingleHeadSiameseAttention Ran
ran on a synthesized input
LONGXUANX/CDFormer_code/models/deformable_transformer.py
code served (permissive licence) · get_code("2f7e49dbedcfed43")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

# Define the classes from the specification
class ScaledDotProductAttention(nn.Module):
    """ Scaled Dot-Product Attention """

    def __init__(self, temperature, attn_dropout=0.0):
        super().__init__()
        self.temperature = temperature
        self.dropout = nn.Dropout(attn_dropout)
        self.softmax = nn.Softmax(dim=2)

    def forward(self, q, k, v):
        attn = torch.bmm(q, k.transpose(1, 2))
        attn = attn / self.temperature
        log_attn = F.log_softmax(attn, 2)
        attn = self.softmax(attn)
        attn = self.dropout(attn)
        output = torch.bmm(attn, v)
        return (output, attn, log_attn)

class SingleHeadSiameseAttention(nn.Module):
    """ Single-Head Attention Module. Weights for Q and K are shared in a Siamese manner. No proj weights for V."""

    def __init__(self, d_model):
        super().__init__()
        self.n_head = 1
        self.d_model = d_model
        self.w_qk = nn.Linear(self.d_model, self.n_head * self.d_model, bias=False)
        self.attention = ScaledDotProductAttention(temperature=np.power(self.d_model, 0.5))
        nn.init.normal_(self.w_qk.weight, mean=0, std=np.sqrt(2.0 / (self.d_model + self.d_model)))
        self.dummy = nn.Parameter(torch.Tensor(1, self.d_model))
        nn.init.normal_(self.dummy)
        self.linear1 = nn.Sequential(nn.Linear(self.d_model, self.d_model // 2), nn.ReLU(inplace=True))
        self.linear2 = nn.Sequential(nn.Linear(self.d_model, self.d_model // 2), nn.ReLU(inplace=True))
        self.linear3 = nn.Linear(self.d_model * 2, self.d_model)

    def forward(self, q, k, v, tsp, supp_class_id):
        sz_b, len_q, _ = q.size()
        sz_b, len_k, _ = k.size()
        sz_b, len_v, _ = v.size()
        sz_b, len_tsp, _ = tsp.size()
        residual = q
        q = self.w_qk(q).view(sz_b, len_q, self.n_head, self.d_model)
        k = self.w_qk(k).view(sz_b, len_k, self.n_head, self.d_model)
        v = v.view(sz_b, len_v, self.n_head, self.d_model)
        tsp = tsp.view(sz_b, len_tsp, self.n_head, self.d_model)
        dummy = self.dummy.reshape(1, 1, 1, self.d_model).expand(sz_b, -1, self.n_head, -1)
        dummy_v = torch.zeros(sz_b, 1, self.n_head, self.d_model, device=v.device)
        k_iter = iter(k.split(1, dim=1))
        list_k = [next(k_iter) if x != 100 else dummy for x in supp_class_id]
        k_cat = torch.cat(list_k, dim=1)
        v_iter = iter(v.split(1, dim=1))
        list_v = [next(v_iter) if x != 100 else dummy_v for x in supp_class_id]
        v_cat = torch.cat(list_v, dim=1)
        k = torch.cat([k_cat, dummy], dim=1)
        v = torch.cat([v_cat, dummy_v], dim=1)
        tsp = torch.cat([tsp, dummy_v], dim=1)
        q = q.permute(2, 0, 1, 3).contiguous().view(-1, len_q, self.d_model)
        k = k.permute(2, 0, 1, 3).contiguous().view(-1, len_tsp + 1, self.d_model)
        v = v.permute(2, 0, 1, 3).contiguous().view(-1, len_tsp + 1, self.d_model)
        tsp = tsp.permute(2, 0, 1, 3).contiguous().view(-1, len_tsp + 1, self.d_model)
        output, attn, log_attn = self.attention(q, k, v)
        tsp, _, _ = self.attention(q, k, tsp)
        output = output.view(self.n_head, sz_b, len_q, self.d_model)
        output = output.permute(1, 2, 0, 3).contiguous().view(sz_b, len_q, -1)
        tsp = tsp.view(self.n_head, sz_b, len_q, self.d_model)
        tsp = tsp.permute(1, 2, 0, 3).contiguous().view(sz_b, len_q, -1)
        output1 = self.linear1(output * residual)
        output2 = self.linear2(residual - output)
        output = self.linear3(torch.cat([output1, output2, residual], dim=2))
        return (output, tsp)

INIT_ARGS = {
    'd_model': 4
}

ARGS = {
    'q': torch.randn(2, 3, 4),
    'k': torch.randn(2, 3, 4),
    'v': torch.randn(2, 3, 4),
    'tsp': torch.randn(2, 2, 4),
    'supp_class_id': [1, 2]
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
_bilinear_grid_sample Ran
ran; our contract draft was wrong, not the code
roboflow/rf-detr/src/rfdetr/models/ops/modules/ms_deform_attn.py
code served (permissive licence) · get_code("f30b488cc19991a3")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 4, dtype family float, shape (2, 4, 2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Create input tensor of shape (N, C, H, W)
# N=2 (batch), C=4 (channels), H=3 (height), W=5 (width)
input_tensor = torch.randn(2, 4, 3, 5)

# Create grid tensor of shape (N, Hg, Wg, 2)
# N=2 (batch), Hg=2 (grid height), Wg=3 (grid width), 2 (x,y coordinates)
# Grid values should be in [-1, 1]
grid_tensor = torch.rand(2, 2, 3, 2) * 2 - 1  # Values in [-1, 1]

ARGS = {
    'input': input_tensor,
    'grid': grid_tensor,
    'padding_mode': 'zeros',
    'align_corners': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 2, 3) — shape (2, 4, 2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
_get_activation_fn Ran
ran; our contract draft was wrong, not the code
LONGXUANX/CDFormer_code/models/deformable_transformer.py
code served (permissive licence) · get_code("c050b2542997c417")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(0)

ARGS = {
    'activation': 'relu'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
_is_power_of_2 Ran
ran, violated the contract we drafted
roboflow/rf-detr/src/rfdetr/models/ops/modules/ms_deform_attn.py
code served (permissive licence) · get_code("f5dd789303b115e9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function _is_power_of_2 takes a single parameter 'n' which must be an int
# It checks if n is a power of 2 using bitwise operations
# Valid inputs are non-negative integers

ARGS = {
    'n': 8  # 8 is 2^3, a valid power of 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
bilinear_grid_sample Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("bf60b14249f09548")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

box_area Ran
ran, honoured the contract we drafted
lyqcom/detr/src/DETR/util.py
code served (permissive licence) · get_code("fcdbd1b86b7ff699")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function box_area takes boxes and computes area by indexing columns
# boxes[:, 0] = x1, boxes[:, 1] = y1, boxes[:, 2] = x2, boxes[:, 3] = y2
# It computes (x2 - x1) * (y2 - y1)
# So boxes should be a tensor with shape (batch_size, 4)

boxes = torch.tensor([
    [0.0, 0.0, 4.0, 3.0],
    [1.0, 1.0, 5.0, 4.0]
], dtype=torch.float32)

ARGS = {
    "boxes": boxes
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
box_cxcywh_to_xyxy Ran
ran on a synthesized input
lyqcom/detr/src/DETR/matcher_np.py
code served (permissive licence) · get_code("074307e51146fa09")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

def box_cxcywh_to_xyxy(x):
    """box cxcywh to xyxy"""
    x_c, y_c, w, h = np.array_split(x, 4, axis=-1)
    b = [x_c - 0.5 * w, y_c - 0.5 * h, x_c + 0.5 * w, y_c + 0.5 * h]
    return np.stack(b, axis=-1).squeeze(-2)

# Create a small input array with shape (2, 4) - batch of 2, 4 values (cx, cy, w, h)
x = np.array([
    [10.0, 20.0, 4.0, 6.0],
    [30.0, 40.0, 8.0, 10.0]
], dtype=np.float32)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
box_xyxy_to_cxcywh Ran
ran on a synthesized input
lyqcom/detr/src/DETR/matcher_np.py
code served (permissive licence) · get_code("dbb0d0f90ff599c4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (1, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# The function expects x to be a numpy array that can be transposed and split
# It should have shape (1, 4) based on the final [0] indexing
# xyxy format: [x0, y0, x1, y1] for bounding boxes

x = np.array([[10.0, 20.0, 50.0, 80.0]])  # shape (1, 4): one box in xyxy format

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (1, 4) — shape (1, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_to_xywh Ran
ran, honoured the contract we drafted
Cedric-Perauer/Deformable_Detr_PIL/datasets/coco_eval.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from yuhangzang/contextdet, is pointer only (licence: NOASSERTION) · get_code("f31a58bf6457ced5")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, Cedric-Perauer/Deformable_Detr_PIL, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

dice_loss Ran
ran, violated the contract we drafted
Cedric-Perauer/Deformable_Detr_PIL/models/segmentation.py
pointer only (licence: Apache-2.0) · get_code("ac8fe530cdad4d8c")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, Cedric-Perauer/Deformable_Detr_PIL, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

evaluate Ran
ran; our contract draft was wrong, not the code
Cedric-Perauer/Deformable_Detr_PIL/datasets/coco_eval.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from yuhangzang/contextdet, is pointer only (licence: NOASSERTION) · get_code("fe0ddcc2d420c9a0")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, Cedric-Perauer/Deformable_Detr_PIL, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

inverse_sigmoid Ran
ran; our contract draft was wrong, not the code
LONGXUANX/CDFormer_code/models/deformable_transformer.py
code served (permissive licence) · get_code("806f660f9474c72d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function takes a tensor x and clamps/processes it
# It uses .clamp() and torch.log() methods on tensors
# x should be a float tensor with values roughly in [0, 1] range

x = torch.tensor([
    [0.1, 0.5, 0.9, 0.99],
    [0.01, 0.25, 0.75, 0.5]
], dtype=torch.float32)

ARGS = {
    "x": x,
    "eps": 1e-06
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
inverse_sigmoid Ran
ran; our contract draft was wrong, not the code
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("a57888d65b00fb2b")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

match_name_keywords Ran
ran, violated the contract we drafted
Cedric-Perauer/Deformable_Detr_PIL/models/deformable_detr.py
pointer only (licence: Apache-2.0) · get_code("c15434906f804d7f")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, Cedric-Perauer/Deformable_Detr_PIL, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

measure_average_inference_time Ran
ran; our contract draft was wrong, not the code
Cedric-Perauer/Deformable_Detr_PIL/benchmark.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from CAMMA-public/OR_anonymization, is pointer only (licence: NOASSERTION) · get_code("3e5d34f155e97585")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, Cedric-Perauer/Deformable_Detr_PIL, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ms_deform_attn_core_pytorch Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
roboflow/rf-detr/src/rfdetr/models/ops/modules/ms_deform_attn.py
code served (permissive licence) · get_code("45e605841eb2a56a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (2, 7, 12) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Understand the function requirements:
# - value: shape (batch_size, n_heads, head_dim, total_spatial_length)
# - value_spatial_shapes: Tensor (not used directly in shown code, but mentioned)
# - sampling_locations: shape depends on merged_levels flag
# - attention_weights: Tensor
# - value_spatial_shapes_hw: list of (height, width) tuples

batch_size = 2
n_heads = 3
head_dim = 4

# Two levels with different spatial shapes to make them distinct
height_0, width_0 = 4, 5
height_1, width_1 = 3, 6

# Total spatial length is sum of all level spatial dimensions
total_spatial_length = height_0 * width_0 + height_1 * width_1

# value shape: (batch_size, n_heads, head_dim, total_spatial_length)
value = torch.randn(batch_size, n_heads, head_dim, total_spatial_length)

# value_spatial_shapes: can be a dummy tensor (not directly used in visible code path)
value_spatial_shapes = torch.tensor([[height_0, width_0], [height_1, width_1]])

# sampling_locations: The code shows it can be 5D (merged_levels=True) or 4D
# For 5D case: (batch_size, len_query, n_heads, num_levels * num_points, 2)
# For 4D case: (batch_size, len_query, n_heads, num_levels, num_points, 2)
# We'll use the merged 5D case
len_query = 7
num_points = 2
num_levels = 2
# 5D merged case
sampling_locations = torch.rand(batch_size, len_query, n_heads, num_levels * num_points, 2)

# attention_weights: typically same spatial structure as sampling_locations
# Shape: (batch_size, len_query, n_heads, num_levels * num_points) for merged case
attention_weights = torch.rand(batch_size, len_query, n_heads, num_levels * num_points)

# value_spatial_shapes_hw: list of (height, width) tuples
value_spatial_shapes_hw = [(height_0, width_0), (height_1, width_1)]

ARGS = {
    'value': value,
    'value_spatial_shapes': value_spatial_shapes,
    'sampling_locations': sampling_locations,
    'attention_weights': attention_weights,
    'value_spatial_shapes_hw': value_spatial_shapes_hw
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 7, 12) — shape (2, 7, 12) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ms_deform_attn_core_pytorch Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("3666672419ef2bd1")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

nested_tensor_from_tensor_list Ran
ran; our contract draft was wrong, not the code
dianzl/sodformer/models/deformable_detr.py
pointer only (licence: NONE) · get_code("a51cb66e9b8cd2fd")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, dianzl/sodformer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

nested_tensor_from_tensor_list Ran
ran; our contract draft was wrong, not the code
duongnv0499/Explain-Deformable-DETR/models/deformable_detr.py
code served (permissive licence) · get_code("9691821ac0f2a520")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned NestedTensor. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from typing import List

torch.manual_seed(0)

# Create a list of 3D tensors with different shapes
# Each tensor has shape (C, H, W) where C=channels, H=height, W=width
tensor1 = torch.randn(3, 4, 5)  # 3 channels, 4 height, 5 width
tensor2 = torch.randn(3, 6, 7)  # 3 channels, 6 height, 7 width

tensor_list = [tensor1, tensor2]

ARGS = {
    "tensor_list": tensor_list
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type NestedTensor — a NestedTensor output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a NestedTensor output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
nested_tensor_from_tensor_list Ran
ran; our contract draft was wrong, not the code
YC-Lai/Sequential-DDETR/models/deformable_detr.py
code served (permissive licence) · get_code("ded2ab6086dcbd94")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned NestedTensor. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from typing import List

torch.manual_seed(0)

# Test case 1: 3D tensors (batch of images)
tensor_3d_1 = torch.randn(3, 4, 5)  # C, H, W
tensor_3d_2 = torch.randn(3, 6, 7)  # C, H, W - different spatial dims
tensor_list_3d = [tensor_3d_1, tensor_3d_2]

# Test case 2: 4D tensors (batch of video sequences)
tensor_4d_1 = torch.randn(2, 3, 4, 5)  # S, C, H, W
tensor_4d_2 = torch.randn(2, 3, 6, 7)  # S, C, H, W - different spatial dims
tensor_list_4d = [tensor_4d_1, tensor_4d_2]

ARGS = {
    "tensor_list": tensor_list_3d
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type NestedTensor — a NestedTensor output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a NestedTensor output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
nested_tensor_from_tensor_list Ran
ran; our contract draft was wrong, not the code
zhechen/deformable-detr-rego/models/deformable_detr.py
code served (permissive licence) · get_code("fe880b26b1a8908a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned NestedTensor. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from typing import List
from torch import Tensor

torch.manual_seed(0)

# Create a list of 3D tensors with different sizes
# Each tensor has shape (C, H, W) where C=channels, H=height, W=width
tensor1 = torch.randn(3, 4, 5)  # 3 channels, 4 height, 5 width
tensor2 = torch.randn(3, 6, 7)  # 3 channels, 6 height, 7 width

tensor_list = [tensor1, tensor2]

ARGS = {
    "tensor_list": tensor_list
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type NestedTensor — a NestedTensor output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a NestedTensor output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
sample_valid_seeds Ran
ran on a synthesized input
haoy945/demf/demf/modeling/detectors/imvotenet_deform.py
code served (permissive licence) · get_code("e79c30fd84dddd35")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family int, shape (2, 1024) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create a mask tensor with shape (batch_size, seed_num*max_imvote_per_pixel)
# batch_size = 2, total seeds = 16
batch_size = 2
total_seeds = 16
mask = torch.randint(0, 2, (batch_size, total_seeds), dtype=torch.bool)

# Ensure at least some valid entries for realistic testing
mask[0, 0] = True
mask[0, 2] = True
mask[0, 5] = True
mask[1, 1] = True
mask[1, 7] = True

num_sampled_seed = 1024

ARGS = {
    "mask": mask,
    "num_sampled_seed": num_sampled_seed,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family int, shape (2, 1024) — shape (2, 1024) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
sigmoid_focal_loss Ran
ran; our contract draft was wrong, not the code
Cedric-Perauer/Deformable_Detr_PIL/models/segmentation.py
pointer only (licence: Apache-2.0) · get_code("5c0711aada67957e")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, Cedric-Perauer/Deformable_Detr_PIL, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

softmax Ran
ran on a synthesized input
lyqcom/detr/src/DETR/matcher_np.py
code served (permissive licence) · get_code("4c36dfd151b487bb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a small numpy array for testing
arr = np.array([[1.0, 2.0, 3.0, 4.0],
                [2.0, 3.0, 4.0, 5.0]])

ARGS = {
    "arr": arr,
    "axis": None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
to_cuda Ran
ran on a synthesized input
Cedric-Perauer/Deformable_Detr_PIL/datasets/data_prefetcher.py
pointer only (licence: Apache-2.0) · get_code("6b447c14f1b53ea9")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, Cedric-Perauer/Deformable_Detr_PIL, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

DeformableDETR Not yet run
unverified (harvested, no recorded run)
YC-Lai/Sequential-DDETR/models/deformable_detr.py
code served (permissive licence) · get_code("a348ef43d0f2a685")
How it ran

no invocation recorded.

DeformableDETR Not yet run
unverified (harvested, no recorded run)
zhechen/deformable-detr-rego/models/deformable_detr.py
code served (permissive licence) · get_code("06c84cdd941f9808")
How it ran

no invocation recorded.

DeformableDETR Not yet run
unverified (harvested, no recorded run)
gokulkarthik/deformable-detr/models/deformable_detr.py
code served (permissive licence) · get_code("182337c7b8edfc5d")
How it ran

no invocation recorded.

DeformableDETR Not yet run
unverified (harvested, no recorded run)
ver0z/Deformable-DETR-/models/deformable_detr.py
code served (permissive licence) · get_code("52318efcaf4667da")
How it ran

no invocation recorded.

DeformableTransformer Not yet run
unverified (harvested, no recorded run)
LONGXUANX/CDFormer_code/models/deformable_transformer.py
code served (permissive licence) · get_code("90478de15357b6af")
How it ran

no invocation recorded.

DeformableTransformer Not yet run
unverified (harvested, no recorded run)
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("6bc8b39c78bd319a")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

DeformableTransformerDecoder Not yet run
unverified (harvested, no recorded run)
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("84635e8f04ac5919")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

DeformableTransformerDecoderLayer Not yet run
unverified (harvested, no recorded run)
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("743a6a5cf7951bcc")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

DeformableTransformerEncoderLayer Not yet run
unverified (harvested, no recorded run)
LONGXUANX/CDFormer_code/models/deformable_transformer.py
code served (permissive licence) · get_code("7fe17a967eb4b659")
How it ran

no invocation recorded.

DeformableTransformerEncoderLayer Not yet run
unverified (harvested, no recorded run)
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("9137d13f22829ae8")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

MSDeformAttn Not yet run
unverified (harvested, no recorded run)
LONGXUANX/CDFormer_code/models/deformable_transformer.py
code served (permissive licence) · get_code("128bb63311a349d1")
How it ran

no invocation recorded.

MSDeformAttn Not yet run
unverified (harvested, no recorded run)
roboflow/rf-detr/src/rfdetr/models/ops/modules/ms_deform_attn.py
code served (permissive licence) · get_code("764de19ef8f2c6e8")
How it ran

no invocation recorded.

MSDeformAttn Not yet run
unverified (harvested, no recorded run)
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("878cb59d722b1377")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

MSDeformAttnFunction Not yet run
unverified (harvested, no recorded run)
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("d01d807bb6de8266")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

MaskHeadSmallConv Not yet run
unverified (harvested, no recorded run)
YC-Lai/Sequential-DDETR/models/deformable_detr.py
code served (permissive licence) · get_code("734f9e92ac03443d")
How it ran

no invocation recorded.

_expand Not yet run
unverified (harvested, no recorded run)
YC-Lai/Sequential-DDETR/models/deformable_detr.py
code served (permissive licence) · get_code("a104be81bc8116a7")
How it ran

no invocation recorded.

load_MultiScaleDeformableAttention Not yet run
unverified (harvested, no recorded run)
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("95940a739db21b62")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

load_ops Not yet run
unverified (harvested, no recorded run)
Visual-Behavior/aloception/alonet/deformable_detr/deformable_transformer.py
pointer only (licence: NOASSERTION) · get_code("f907a86f3f649ae2")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Visual-Behavior/aloception (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

Also present in other papers' code

Of 55 samples lifted from this paper's linked repositories, 55 carry a function identity and 0 do not. Of the 55 distinct functions with an identity, 16 are also present in other papers whose code we hold (11 with at least one paper dated earlier, 0 the same month, 14 later) and 39 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
MLP
brick of this paper's assembly: helper
68 other papers
1 dated earlier, 67 later · 58 only as an assembly brick
2005.12872 (2020-05)
End-to-End Object Detection with Transformers
2101.01909 (2021-01)
Line Segment Detection Using Transformers without Edges
2102.01894 (2021-02)
Relaxed Transformer Decoders for Direct Action Proposal Generation
and 65 more not named here
sigmoid_focal_loss 56 other papers
1 dated earlier, 55 later · 1 only as an assembly brick
2005.12872 (2020-05)
End-to-End Object Detection with Transformers
2103.11731 (2021-03)
Meta-DETR: Image-Level Few-Shot Object Detection with Inter-Class Correlation Exploitation
2103.12115 (2021-03)
End-to-End Trainable Multi-Instance Pose Estimation with Transformers
and 53 more not named here
dice_loss 40 other papers
1 dated earlier, 39 later · 1 only as an assembly brick
2005.12872 (2020-05)
End-to-End Object Detection with Transformers
2103.12115 (2021-03)
End-to-End Trainable Multi-Instance Pose Estimation with Transformers
2104.12763 (2021-04)
MDETR -Modulated Detection for End-to-End Multi-Modal Understanding
and 37 more not named here
convert_to_xywh 24 other papers
1 dated earlier, 23 later
1512.02325 (2015-12)
SSD: Single Shot MultiBox Detector
2103.11731 (2021-03)
Meta-DETR: Image-Level Few-Shot Object Detection with Inter-Class Correlation Exploitation
2103.12115 (2021-03)
End-to-End Trainable Multi-Instance Pose Estimation with Transformers
and 21 more not named here
evaluate 23 other papers
1 dated earlier, 22 later
1512.02325 (2015-12)
SSD: Single Shot MultiBox Detector
2103.11731 (2021-03)
Meta-DETR: Image-Level Few-Shot Object Detection with Inter-Class Correlation Exploitation
2103.12115 (2021-03)
End-to-End Trainable Multi-Instance Pose Estimation with Transformers
and 20 more not named here
nested_tensor_from_tensor_list
brick of this paper's assembly: helper
19 other papers
1 dated earlier, 18 later · 11 only as an assembly brick
2005.12872 (2020-05)
End-to-End Object Detection with Transformers
2103.05399 (2021-03)
QPIC: Query-Based Pairwise Human-Object Interaction Detection with Image-Wide Contextual Information
2103.05983 (2021-03)
Reformulating HOI Detection as Adaptive Set Prediction
and 16 more not named here
match_name_keywords 13 other papers
13 later
2111.04076 (2021-11)
Direct Multi-view Multi-person 3D Pose Estimation
2206.11134 (2022-06)
Open Vocabulary Object Detection with Proposal Mining and Prediction Equalization
2207.13080 (2022-07)
DETRs with Hybrid Matching
and 10 more not named here
measure_average_inference_time 10 other papers
10 later
2106.04550 (2021-06)
DETReg: Unsupervised Pretraining with Region Priors for Object Detection
ijcai2022_0136 (2022 (year only))
AQT: Adversarial Query Transformers for Domain Adaptive Object Detection
and 7 more not named here
MSDeformAttn
brick of this paper's assembly: model
6 other papers
6 later
2103.11161 (2021-03)
MonteFloor: Extending MCTS for Reconstructing Accurate Large-Scale Floor Plans
2209.02242 (2022-09)
PTSEFormer: Progressive Temporal-Spatial Enhanced TransFormer Towards Video Object Detection
2308.09351 (2023-08)
RLIPv2: Fast Scaling of Relational Language-Image Pre-training
and 3 more not named here
box_area 3 other papers
2 dated earlier, 1 later
1506.01497 (2015-06)
Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
box_cxcywh_to_xyxy 2 other papers
1 dated earlier, 1 later
2005.12872 (2020-05)
End-to-End Object Detection with Transformers
2307.12612 (2023-07)
Less is More: Focus Attention for Efficient DETR
box_xyxy_to_cxcywh 2 other papers
1 dated earlier, 1 later
2005.12872 (2020-05)
End-to-End Object Detection with Transformers
2307.12612 (2023-07)
Less is More: Focus Attention for Efficient DETR
DeformableDETR
brick of this paper's assembly: entry
1 other paper
1 dated earlier
2005.12872 (2020-05)
End-to-End Object Detection with Transformers
_expand
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2207.14012 (2022-07)
Video Mask Transfiner for High-Quality Video Instance Segmentation
softmax 1 other paper
1 dated earlier
2005.12872 (2020-05)
End-to-End Object Detection with Transformers
to_cuda 1 other paper
1 later
2106.03089 (2021-06)
Referring Transformer: A One-step Approach to Multi-task Visual Grounding

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

DETR has been recently proposed to eliminate the need for many hand-designed components in object detection while demonstrating good performance. However, it suffers from slow convergence and limited feature spatial resolution, due to the limitation of Transformer attention modules in processing image feature maps. To mitigate these issues, we proposed Deformable DETR, whose attention modules only attend to a small set of key sampling points around a reference. Deformable DETR can achieve better performance than DETR (especially on small objects) with 10× less training epochs. Extensive experiments on the COCO benchmark demonstrate the effectiveness of our approach. Code is released at https:// github.com/fundamentalvision/Deformable-DETR.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2010.04159")
get_code_for_paper("2010.04159")
have("2010.04159")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2010.04159.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2010.04159.svg)](https://syntology.ai/paper/2010.04159)

Connect an agent — have() is free.