SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1904.01355 · 2019

FCOS: Fully Convolutional One-Stage Object Detection

arXiv · PDF · Open in the Atlas

Code that ran

37 of 40 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 2 violated it and 20 have no contract verdict; 13 failures of our instrument; 3 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/1904.01355.json · badge: /api/ran/1904.01355.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
xytpai/fcos community (classifier label)
classifier basis not recorded on the link
6 ran · 0 no recorded run
srihari-humbarwadi/tensorflow_fcos community (classifier label)
classifier basis not recorded on the link
6 ran · 0 no recorded run
ricky40403/Fcos_seg community (classifier label)
classifier basis not recorded on the link
5 ran · 2 no recorded run
BIYTC/mobilenet_maskrcnn community (classifier label)
classifier basis not recorded on the link
4 ran · 0 no recorded run
Iamal1/maskrcnn-benchmark community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
tuananh1007/Faster-R-CNN-and-Mask-R-CNN-in-PyTorch-1.0 community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
Zanderzt/TensorRT_Mask_RCNN community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
kohillyang/mx-detection reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
markson14/WheatDet community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
latentgnn/maskrcnn-benchmark-latentgnn extension (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
rosinality/fcos-pytorch reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
zhongzisha/object_detection reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
PeterTKovacs/zold137 community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
lijain/FCOS-change extension (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
FluteXu/ms-project extension (classifier label)
classifier basis: classifier_2025
0 ran · 1 no recorded run
FunctionStatusWhere it lives
LR Ran
ran on a synthesized input
Zanderzt/TensorRT_Mask_RCNN/demo/zyw.py
pointer only (licence: MIT) · get_code("0eaf951d3a22588b")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, Zanderzt/TensorRT_Mask_RCNN, 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.

RF Ran
ran on a synthesized input
Zanderzt/TensorRT_Mask_RCNN/demo/zyw.py
pointer only (licence: MIT) · get_code("00700fd67cb3e29a")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, Zanderzt/TensorRT_Mask_RCNN, 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.

balanced_l1_loss Ran
ran on a synthesized input
Iamal1/maskrcnn-benchmark/maskrcnn_benchmark/layers/balanced_l1_loss.py
pointer only (licence: MIT) · get_code("cf6230491f9702dc")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, Iamal1/maskrcnn-benchmark, 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.

batch_fn Ran
ran, honoured the contract we drafted
kohillyang/mx-detection/scripts/train_fcos.py
pointer only (licence: NONE) · get_code("d0b9e262619a0908")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, kohillyang/mx-detection 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.

bbox_overlaps_aligned Ran
ran on a synthesized input
xytpai/fcos/libs/iou_loss.py
code served (permissive licence) · get_code("318c2c9407b81028")
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)

# Create two small bounding box tensors
# Format: (ymin, xmin, ymax, xmax)
bboxes1 = torch.tensor([
    [10.0, 20.0, 50.0, 60.0],
    [15.0, 25.0, 45.0, 55.0]
], dtype=torch.float32)

bboxes2 = torch.tensor([
    [20.0, 30.0, 60.0, 70.0],
    [10.0, 20.0, 40.0, 50.0]
], dtype=torch.float32)

ARGS = {
    "bboxes1": bboxes1,
    "bboxes2": bboxes2,
    "is_aligned": 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 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
centerness_loss Ran
ran on a synthesized input
srihari-humbarwadi/tensorflow_fcos/tensorflow_fcos/models/fcos/losses.py
code served (permissive licence) · get_code("987c1ea87f06ee22")
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 EagerTensor, 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 tensorflow as tf
import numpy as np

# Create small test tensors for the centerness_loss function
batch_size = 2
num_anchors = 4

# labels: shape (batch_size, num_anchors) - binary labels for foreground/background
labels = tf.constant(
    [[1.0, 0.0, 1.0, 0.0],
     [0.0, 1.0, 0.0, 1.0]],
    dtype=tf.float32
)

# logits: shape (batch_size, num_anchors) - raw model outputs
logits = tf.constant(
    [[0.5, -0.3, 0.8, -0.1],
     [-0.2, 0.6, 0.1, -0.5]],
    dtype=tf.float32
)

# fg_mask: shape (batch_size,) - boolean mask for foreground samples
fg_mask = tf.constant(
    [1.0, 1.0],
    dtype=tf.float32
)

# normalizer_value: scalar - normalization factor
normalizer_value = tf.constant(2.0, dtype=tf.float32)

ARGS = {
    "labels": labels,
    "logits": logits,
    "fg_mask": fg_mask,
    "normalizer_value": normalizer_value,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, 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
conv1x1 Ran
ran; our contract draft was wrong, not the code
ricky40403/Fcos_seg/Fcos_seg/backbone/resnet.py
code served (permissive licence) · get_code("d9def42110729a85")
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 Conv2d. 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)

# The function conv1x1 takes in_planes, out_planes, and stride as parameters
# It returns an nn.Conv2d layer configured for 1x1 convolution
# We need to provide valid integer arguments for these parameters

ARGS = {
    "in_planes": 3,
    "out_planes": 64,
    "stride": 1
}
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 Conv2d — a Conv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv2d 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
conv1x1 Ran
ran on a synthesized input
ricky40403/Fcos_seg/Fcos_seg/backbone/volvenet.py
code served (permissive licence) · get_code("9e931093b7cb657e")
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 list, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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 = {
    'in_channels': 64,
    'out_channels': 128,
    'module_name': 'layer',
    'postfix': '0',
    'stride': 1,
    'groups': 1,
    'kernel_size': 1,
    'padding': 0
}
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 list, ndim 2, dtype family float — a list output has no array shape of its own; none is stated
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
conv3x3 Ran
ran; our contract draft was wrong, not the code
ricky40403/Fcos_seg/Fcos_seg/backbone/resnet.py
code served (permissive licence) · get_code("160bb14bd76201b4")
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 Conv2d. 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 = {
    "in_planes": 3,
    "out_planes": 64,
    "stride": 1,
    "groups": 1,
    "dilation": 1,
}
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 Conv2d — a Conv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv2d 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
conv3x3 Ran
ran; our contract draft was wrong, not the code
xytpai/fcos/backbone.py
pointer only (licence: MIT); the stored copy get_code serves, from lixiaotong97/DSU, is pointer only (licence: NONE) · get_code("fac5364e2f53c6db")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from lixiaotong97/DSU, and GitHub detected no licence in that repository 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.

conv3x3 Ran
ran on a synthesized input
ricky40403/Fcos_seg/Fcos_seg/backbone/volvenet.py
code served (permissive licence) · get_code("971b790fc16af272")
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 list, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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 = {
    'in_channels': 3,
    'out_channels': 64,
    'module_name': 'layer',
    'postfix': '0',
    'stride': 1,
    'groups': 1,
    'kernel_size': 3,
    'padding': 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 list, ndim 2, dtype family float — a list output has no array shape of its own; none is stated
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
conv_block Ran
ran on a synthesized input
srihari-humbarwadi/tensorflow_fcos/tensorflow_fcos/models/blocks.py
code served (permissive licence) · get_code("43351463fea5b39a")
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 KerasTensor. 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 tensorflow as tf
from tensorflow.keras.layers import Input

# Create a small input tensor for the conv_block function
# Using batch size 2 and spatial dimensions 4x4
input_tensor = Input(shape=(4, 4, 3))

ARGS = {
    'input_tensor': input_tensor,
    'filters': 32,
    'kernel_size': 3,
    'strides': 1,
    'padding': 'same',
    'kernel_init': 'he_normal',
    'bias_init': 'zeros',
    'bn_act': True,
    'name_prefix': 'block1'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type KerasTensor — a KerasTensor 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: none by the harness; any seed is in the setup block
draw_boxes_cv2 Ran
ran on a synthesized input
srihari-humbarwadi/tensorflow_fcos/tensorflow_fcos/utils/visualization.py
code served (permissive licence) · get_code("f900af0f07e48e3f")
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 3, dtype family int, shape (480, 640, 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 cv2
import numpy as np

# Create a small test image
image = np.random.randint(0, 256, (480, 640, 3), dtype=np.uint8)

# Create bounding boxes in format [x1, y1, x2, y2]
# These are in normalized coordinates relative to H, W
bbox_list = [
    [100, 150, 250, 300],
    [50, 75, 200, 180]
]

# Original image dimensions that the bboxes are normalized to
H = 480
W = 640

ARGS = {
    "image": image,
    "bbox_list": bbox_list,
    "H": H,
    "W": W
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (480, 640, 3) — shape (480, 640, 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
expand_boxes Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
tuananh1007/Faster-R-CNN-and-Mask-R-CNN-in-PyTorch-1.0/maskrcnn_benchmark/modeling/roi_heads/mask_head/inference.py
pointer only (licence: MIT); the stored copy get_code serves, from tiankongzhang/nsa, is pointer only (licence: NONE) · get_code("5362c4106bc79217")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, tuananh1007/Faster-R-CNN-and-Mask-R-CNN-in-PyTorch-1.0, 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.

expand_masks Ran
ran on a synthesized input
tuananh1007/Faster-R-CNN-and-Mask-R-CNN-in-PyTorch-1.0/maskrcnn_benchmark/modeling/roi_heads/mask_head/inference.py
pointer only (licence: MIT) · get_code("762ce037e4512c48")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, tuananh1007/Faster-R-CNN-and-Mask-R-CNN-in-PyTorch-1.0, 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.

focal_loss Ran
ran on a synthesized input
srihari-humbarwadi/tensorflow_fcos/tensorflow_fcos/models/fcos/losses.py
code served (permissive licence) · get_code("fce50f2fda34fc22")
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 EagerTensor, ndim 2, dtype family float, shape (2, 1) 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 tensorflow as tf
import numpy as np

# Set seed for reproducibility
tf.random.set_seed(0)
np.random.seed(0)

# Create small test tensors
batch_size = 2
num_classes = 10
spatial_dim = 4

# y_true: class indices, shape (batch_size, spatial_dim)
# Values should be in range [0, num_classes]
y_true = tf.constant(np.random.randint(0, num_classes + 1, size=(batch_size, spatial_dim)), dtype=tf.int64)

# y_pred: logits, shape (batch_size, spatial_dim, num_classes)
y_pred = tf.constant(np.random.randn(batch_size, spatial_dim, num_classes).astype(np.float32), dtype=tf.float32)

# normalizer_value: scalar tensor to normalize the loss
normalizer_value = tf.constant(1.0, dtype=tf.float32)

# num_classes: integer parameter
num_classes_param = 10

# alpha: float parameter for focal loss
alpha = 0.25

# gamma: float parameter for focal loss
gamma = 2.0

ARGS = {
    "y_true": y_true,
    "y_pred": y_pred,
    "normalizer_value": normalizer_value,
    "num_classes": num_classes_param,
    "alpha": alpha,
    "gamma": gamma,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 2, dtype family float, shape (2, 1) — shape (2, 1) 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
format_prediction_string Ran
ran on a synthesized input
markson14/WheatDet/demo/wheat_inference.py
pointer only (licence: MIT) · get_code("069333d11241eccd")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, markson14/WheatDet, 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.

get_group_gn Ran
ran on a synthesized input
BIYTC/mobilenet_maskrcnn/maskrcnn_benchmark/modeling/make_layers.py
pointer only (licence: MIT); the stored copy get_code serves, from JoyHuYY1412/LST_LVIS, is pointer only (licence: MIT) · get_code("83c64313d0501174")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, BIYTC/mobilenet_maskrcnn, 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.

get_loss Ran
ran; our contract draft was wrong, not the code
xytpai/fcos/detector.py
code served (permissive licence) · get_code("bafd66dce4d45e2a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned Tensor, 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)

temp = torch.randn(2, 4)

ARGS = {
    'temp': temp
}
Setup block drafted by
a language model, Claude Sonnet 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 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
get_lr Ran
ran, honoured the contract we drafted
this paper's copy was not recorded; identical code first harvested from yjzhang96/UTI-VFI
pointer only; the stored copy get_code serves, from yjzhang96/UTI-VFI, is pointer only (licence: NONE) · get_code("7337f1f5ff01dcd0")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for 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.

has_valid_annotation Ran
ran, violated the contract we drafted
latentgnn/maskrcnn-benchmark-latentgnn/maskrcnn_benchmark/data/datasets/coco.py
code served (permissive licence) · get_code("2531c930ac17dddf")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 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
import numpy as np

torch.manual_seed(0)

# The function expects 'anno' which is a list of annotation dictionaries
# Each annotation dict can have:
# - 'bbox': a list/array with at least 4 elements [x, y, width, height]
# - 'keypoints': a list where every 3rd element (starting from index 2) is a visibility flag

# Create a valid annotation with keypoints
anno_valid = [
    {
        'bbox': [10, 20, 50, 60],  # valid bbox with width=50, height=60
        'keypoints': [
            100, 200, 2,  # keypoint 1: x, y, visibility=2 (visible)
            110, 210, 1,  # keypoint 2: x, y, visibility=1 (visible)
            120, 220, 2,  # keypoint 3: x, y, visibility=2 (visible)
            130, 230, 0,  # keypoint 4: x, y, visibility=0 (not visible)
            140, 240, 2,  # keypoint 5: x, y, visibility=2 (visible)
            150, 250, 1,  # keypoint 6: x, y, visibility=1 (visible)
            160, 260, 2,  # keypoint 7: x, y, visibility=2 (visible)
            170, 270, 2,  # keypoint 8: x, y, visibility=2 (visible)
            180, 280, 1,  # keypoint 9: x, y, visibility=1 (visible)
            190, 290, 2,  # keypoint 10: x, y, visibility=2 (visible)
            200, 300, 2,  # keypoint 11: x, y, visibility=2 (visible)
        ]
    },
    {
        'bbox': [15, 25, 55, 65],
        'keypoints': [
            105, 205, 1,
            115, 215, 0,
            125, 225, 1,
        ]
    }
]

ARGS = {'anno': anno_valid}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy, 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
interpolate Ran
ran; our contract draft was wrong, not the code
BIYTC/mobilenet_maskrcnn/maskrcnn_benchmark/layers/misc.py
pointer only (licence: MIT); the stored copy get_code serves, from KanghoonYoon/torch-rasgg, is pointer only (licence: NONE) · get_code("2902bf4410253ff7")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, BIYTC/mobilenet_maskrcnn, 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.

iou_loss Ran
ran on a synthesized input
srihari-humbarwadi/tensorflow_fcos/tensorflow_fcos/models/fcos/losses.py
code served (permissive licence) · get_code("5e47641ad906ae7b")
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 EagerTensor, ndim 2, dtype family float, shape (2, 1) 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 tensorflow as tf
import numpy as np

# Set random seed for reproducibility
np.random.seed(0)
tf.random.set_seed(0)

# Create small test tensors
batch_size = 2
num_anchors = 4
box_dims = 4

# labels: shape (batch_size, num_anchors, 4) - contains [top, left, bottom, right] offsets
labels = tf.constant(np.random.randn(batch_size, num_anchors, box_dims).astype(np.float32))

# logits: shape (batch_size, num_anchors, 4) - predicted box offsets
logits = tf.constant(np.random.randn(batch_size, num_anchors, box_dims).astype(np.float32))

# centers: shape (batch_size, num_anchors, 2) - anchor box centers [x, y]
centers = tf.constant(np.random.randn(batch_size, num_anchors, 2).astype(np.float32) + 10.0)

# fg_mask: shape (batch_size, num_anchors) - foreground mask (0 or 1)
fg_mask = tf.constant(np.random.randint(0, 2, size=(batch_size, num_anchors)).astype(np.float32))

# normalizer_value: scalar - normalization factor
normalizer_value = tf.constant(np.array([batch_size * num_anchors], dtype=np.float32))

ARGS = {
    "labels": labels,
    "logits": logits,
    "centers": centers,
    "fg_mask": fg_mask,
    "normalizer_value": normalizer_value,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 2, dtype family float, shape (2, 1) — shape (2, 1) 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
iou_loss Ran
ran on a synthesized input
xytpai/fcos/libs/iou_loss.py
code served (permissive licence) · get_code("dbd9612822534e83")
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)

# Create sample bounding boxes in format (ymin, xmin, ymax, xmax)
pred = torch.tensor([
    [10.0, 20.0, 50.0, 60.0],
    [15.0, 25.0, 55.0, 65.0]
], dtype=torch.float32)

target = torch.tensor([
    [12.0, 22.0, 52.0, 62.0],
    [14.0, 24.0, 54.0, 64.0]
], dtype=torch.float32)

ARGS = {
    "pred": pred,
    "target": target,
    "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 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
l2_loss Ran
ran on a synthesized input
Iamal1/maskrcnn-benchmark/maskrcnn_benchmark/layers/l2_loss.py
pointer only (licence: MIT); the stored copy get_code serves, from SIAAAAAA/MMT-PSM, is pointer only (licence: MIT) · get_code("5ab322eae8b53480")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, Iamal1/maskrcnn-benchmark, 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.

make_coco_detection Ran
ran; our contract draft was wrong, not the code
rosinality/fcos-pytorch/evaluate.py
code served (permissive licence) · get_code("96e93f6459e7f4bd")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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

torch.manual_seed(0)

class BoundingBox:
    def __init__(self, boxes, mode='xyxy'):
        self.boxes = boxes
        self.mode = mode
    
    def resize(self, size):
        # Return a new BoundingBox with resized coordinates
        width, height = size
        # Simple resize logic (just scale the boxes)
        resized = BoundingBox(self.boxes.clone(), self.mode)
        return resized
    
    def convert(self, mode):
        # Convert to xywh format
        converted = BoundingBox(self.boxes.clone(), mode)
        converted.box = self.boxes  # Store as box attribute
        return converted

class Prediction:
    def __init__(self, boxes, scores, labels):
        self.bbox = BoundingBox(boxes)
        self.fields = {
            'scores': scores,
            'labels': labels
        }
        self.box = boxes
    
    def __len__(self):
        return len(self.box)
    
    def resize(self, size):
        # Return a new Prediction with resized boxes
        resized_pred = Prediction(self.box.clone(), self.fields['scores'].clone(), self.fields['labels'].clone())
        return resized_pred
    
    def convert(self, mode):
        # Return self with box attribute set
        return self

class Dataset:
    def __init__(self):
        self.id2img = {0: 100, 1: 101}  # Map internal id to original image id
        self.id2category = {1: 10, 2: 20, 3: 30}  # Map label id to category id
        self.image_metas = {
            0: {'width': 640, 'height': 480},
            1: {'width': 800, 'height': 600}
        }
    
    def get_image_meta(self, id):
        return self.image_metas[id]

# Create predictions
# Prediction 0: 2 boxes
boxes_0 = torch.tensor([[10.0, 20.0, 30.0, 40.0],
                        [50.0, 60.0, 70.0, 80.0]])
scores_0 = torch.tensor([0.9, 0.8])
labels_0 = torch.tensor([1, 2])

pred_0 = Prediction(boxes_0, scores_0, labels_0)

# Prediction 1: 1 box
boxes_1 = torch.tensor([[15.0, 25.0, 35.0, 45.0]])
scores_1 = torch.tensor([0.95])
labels_1 = torch.tensor([3])

pred_1 = Prediction(boxes_1, scores_1, labels_1)

predictions = [pred_0, pred_1]

dataset = Dataset()

ARGS = {
    'predictions': predictions,
    'dataset': dataset
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
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
nms Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
zhongzisha/object_detection/train_FCOS.py
pointer only (licence: NONE) · get_code("99d667302be1c9e3")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, zhongzisha/object_detection 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.

project_masks_on_boxes Ran
ran on a synthesized input
tuananh1007/Faster-R-CNN-and-Mask-R-CNN-in-PyTorch-1.0/maskrcnn_benchmark/modeling/roi_heads/mask_head/loss.py
pointer only (licence: MIT) · get_code("7282d9e488dd0a6d")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, tuananh1007/Faster-R-CNN-and-Mask-R-CNN-in-PyTorch-1.0, 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.

read_custom_dict Ran
ran on a synthesized input
PeterTKovacs/zold137/drone_demo/custom_train.py
pointer only (licence: MIT) · get_code("84fb771ac13f3af1")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, PeterTKovacs/zold137, 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.

reduce_sum Ran
ran, violated the contract we drafted
lijain/FCOS-change/fcos_core/modeling/rpn/fcos/loss.py
pointer only (licence: NONE) · get_code("73567c93e91cf2f7")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, lijain/FCOS-change 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.

resnet18 Ran
ran; our contract draft was wrong, not the code
xytpai/fcos/backbone.py
code served (permissive licence) · get_code("66e10ac6440feae6")
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 ResNet. 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)

ARGS = {
    'pretrained': 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 ResNet — a ResNet output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ResNet 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
resnet34 Ran
ran; our contract draft was wrong, not the code
xytpai/fcos/backbone.py
code served (permissive licence) · get_code("fabaffc1a606ef9b")
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 ResNet. 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)

ARGS = {
    'pretrained': 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 ResNet — a ResNet output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ResNet 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
sigmoid_focal_loss_cpu Ran
ran; our contract draft was wrong, not the code
Iamal1/maskrcnn-benchmark/maskrcnn_benchmark/layers/sigmoid_focal_loss.py
pointer only (licence: MIT); the stored copy get_code serves, from KanghoonYoon/torch-rasgg, is pointer only (licence: NONE) · get_code("426fd02a2beaf826")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, Iamal1/maskrcnn-benchmark, 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.

sigmoid_focal_loss_cpu Ran
ran; our contract draft was wrong, not the code
BIYTC/mobilenet_maskrcnn/maskrcnn_benchmark/layers/sigmoid_focal_loss.py
pointer only (licence: MIT) · get_code("c42eaa8eb1b704cd")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, BIYTC/mobilenet_maskrcnn, 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.

smooth_l1_loss Ran
ran; our contract draft was wrong, not the code
BIYTC/mobilenet_maskrcnn/maskrcnn_benchmark/layers/smooth_l1_loss.py
pointer only (licence: MIT) · get_code("e261fa29066b37e5")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, BIYTC/mobilenet_maskrcnn, 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.

upsample_like Ran
ran on a synthesized input
srihari-humbarwadi/tensorflow_fcos/tensorflow_fcos/models/blocks.py
code served (permissive licence) · get_code("11565a347678ccac")
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 EagerTensor, ndim 4, dtype family float, shape (2, 8, 6, 5) 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 tensorflow as tf
import numpy as np

# Create input tensor: batch_size=2, height=4, width=3, channels=5
input_tensor = tf.constant(np.random.randn(2, 4, 3, 5).astype(np.float32))

# Create target tensor: batch_size=2, height=8, width=6, channels=5
# Different height and width so upsampling is visible
target_tensor = tf.constant(np.random.randn(2, 8, 6, 5).astype(np.float32))

# name parameter is optional
name = "upsample_test"

ARGS = {
    "input_tensor": input_tensor,
    "target_tensor": target_tensor,
    "name": name
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 4, dtype family float, shape (2, 8, 6, 5) — shape (2, 8, 6, 5) 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
vovnet57 Ran
ran on a synthesized input
ricky40403/Fcos_seg/Fcos_seg/backbone/volvenet.py
code served (permissive licence) · get_code("f9f03971f1bab8c1")
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 VoVNet. 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 collections import OrderedDict

torch.manual_seed(0)

ARGS = {
    'pretrained': False,
    'progress': True,
}
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 VoVNet — a VoVNet output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a VoVNet 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
build_roi_box_head Not yet run
unverified (harvested, no recorded run)
FluteXu/ms-project/build/lib.linux-x86_64-3.7/maskrcnn_benchmark/modeling/roi_heads/box_head/box_head.py
code served (permissive licence) · get_code("cf6c9b5f6174fc81")
How it ran

no invocation recorded.

make_coco_detection Not yet run
unverified (harvested, no recorded run)
ricky40403/Fcos_seg/Fcos_seg/core/coco_eval.py
code served (permissive licence) · get_code("c5c7f9c741faf54d")
How it ran

no invocation recorded.

resnet18 Not yet run
unverified (harvested, no recorded run)
ricky40403/Fcos_seg/Fcos_seg/backbone/resnet.py
code served (permissive licence) · get_code("fc9af2f2cc533781")
How it ran

no invocation recorded.

Also present in other papers' code

Of 40 samples lifted from this paper's linked repositories, 40 carry a function identity and 0 do not. Of the 40 distinct functions with an identity, 21 are also present in other papers whose code we hold (15 with at least one paper dated earlier, 9 the same month, 19 later) and 19 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
conv3x3 686 other papers
102 dated earlier, 16 the same month, 568 later · 31 only as an assembly brick
1406.2661 (2014-06)
Generative Adversarial Networks
1409.0575 (2014-09)
ImageNet Large Scale Visual Recognition Challenge
1412.6572 (2014-12)
Explaining and Harnessing Adversarial Examples
and 683 more not named here
conv1x1 431 other papers
27 dated earlier, 5 the same month, 398 later, 1 undated · 38 only as an assembly brick
1409.1556 (2014-09)
Very Deep Convolutional Networks for Large-Scale Image Recognition
1506.01186 (2015-06)
Cyclical Learning Rates for Training Neural Networks
1507.05717 (2015-07)
An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition
and 428 more not named here
conv3x3 312 other papers
11 dated earlier, 2 the same month, 298 later, 1 undated · 31 only as an assembly brick
1409.1556 (2014-09)
Very Deep Convolutional Networks for Large-Scale Image Recognition
1507.05717 (2015-07)
An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
and 309 more not named here
resnet18 95 other papers
2 dated earlier, 92 later, 1 undated
1805.00907 (2018-05)
Glow: Graph Lowering Compiler Techniques for Neural Networks
1902.08153 (2019-02)
Learned Step Size Quantization
1911.06487 (2019-11)
OpenLORIS-Object: A Robotic Vision Dataset and Benchmark for Lifelong Deep Learning
and 92 more not named here
resnet18 89 other papers
11 dated earlier, 3 the same month, 75 later
1705.09759 (2017-05)
CASENet: Deep Category-Aware Semantic Edge Detection
1801.07698 (2018-01)
ArcFace: Additive Angular Margin Loss for Deep Face Recognition
1803.00839 (2018-03)
Pose-Robust Face Recognition via Deep Residual Equivariant Mapping
and 86 more not named here
resnet34 53 other papers
10 dated earlier, 3 the same month, 40 later
1705.09759 (2017-05)
CASENet: Deep Category-Aware Semantic Edge Detection
1801.07698 (2018-01)
ArcFace: Additive Angular Margin Loss for Deep Face Recognition
1803.00839 (2018-03)
Pose-Robust Face Recognition via Deep Residual Equivariant Mapping
and 50 more not named here
interpolate 38 other papers
5 dated earlier, 1 the same month, 32 later
1703.06870 (2017-03)
Mask R-CNN
1803.03243 (2018-03)
Domain Adaptive Faster R-CNN for Object Detection in the Wild
1807.08865 (2018-07)
StereoNet: Guided Hierarchical Refinement for Real-Time Edge-Aware Depth Prediction
and 35 more not named here
get_lr 25 other papers
2 dated earlier, 23 later · 2 only as an assembly brick
1605.07148 (2016-05)
Backprop KF: Learning Discriminative Deterministic State Estimators
1606.00915 (2016-06)
DeepLab: Semantic Image Segmentation with Deep Convolutional Nets, Atrous Convolution, and Fully Connected CRFs
1912.02923 (2019-12)
Generating 3D People in Scenes without People
and 22 more not named here
smooth_l1_loss 16 other papers
2 dated earlier, 1 the same month, 13 later
1703.06870 (2017-03)
Mask R-CNN
1903.00241 (2019-03)
Mask Scoring R-CNN
1904.01169 (2019-04)
Res2Net: A New Multi-scale Backbone Architecture
and 13 more not named here
sigmoid_focal_loss_cpu 10 other papers
1 dated earlier, 1 the same month, 8 later
1803.03243 (2018-03)
Domain Adaptive Faster R-CNN for Object Detection in the Wild
1904.01169 (2019-04)
Res2Net: A New Multi-scale Backbone Architecture
2001.03398 (2020-01)
DSGN: Deep Stereo Geometry Network for 3D Object Detection
and 7 more not named here
sigmoid_focal_loss_cpu 7 other papers
1 dated earlier, 6 later
1703.06870 (2017-03)
Mask R-CNN
2002.12204 (2020-02)
Visual Commonsense R-CNN
2007.07986 (2020-07)
Boosting Weakly Supervised Object Detection with Progressive Knowledge Transfer
and 4 more not named here
get_group_gn 3 other papers
1 dated earlier, 2 later
1703.06870 (2017-03)
Mask R-CNN
2004.00900 (2020-04)
Learning to Segment the Tail
2111.12698 (2021-11)
Open-Vocabulary Instance Segmentation via Robust Cross-Modal Pseudo-Labeling
build_roi_box_head 2 other papers
2 later
2002.10200 (2020-02)
ABCNet: Real-time Scene Text Spotting with Adaptive Bezier-Curve Network
2007.09384 (2020-07)
Multi-Scale Positive Sample Refinement for Few-Shot Object Detection
expand_boxes 2 other papers
2 later
2010.13757 (2020-10)
Instance Semantic Segmentation Benefits from Generative Adversarial Networks
2308.08182 (2023-08)
Unsupervised Domain Adaptive Detection with Network Stability Analysis
l2_loss 2 other papers
1 dated earlier, 1 later
1903.00241 (2019-03)
Mask Scoring R-CNN
2007.10787 (2020-07)
Deep Semi-supervised Knowledge Distillation for Overlapping Cervical Cell Instance Segmentation
nms 2 other papers
1 dated earlier, 1 the same month
1708.02002 (2017-08)
Focal Loss for Dense Object Detection
1904.08900 (2019-04)
CornerNet-Lite: Efficient Keypoint Based Object Detection
expand_masks 1 other paper
1 later
2010.13757 (2020-10)
Instance Semantic Segmentation Benefits from Generative Adversarial Networks
get_loss 1 other paper
1 dated earlier
1708.02002 (2017-08)
Focal Loss for Dense Object Detection
has_valid_annotation 1 other paper
1 later
2004.06002 (2020-04)
Dynamic R-CNN: Towards High Quality Object Detection via Dynamic Training
project_masks_on_boxes 1 other paper
1 later
2010.13757 (2020-10)
Instance Semantic Segmentation Benefits from Generative Adversarial Networks

Shown: the 20 functions present in the most other papers. 1 more shared functions are not listed here.

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

More are linked than shown here.

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

Abstract

We propose a fully convolutional one-stage object detector (FCOS) to solve object detection in a per-pixel prediction fashion, analogue to semantic segmentation. Almost all state-of-the-art object detectors such as RetinaNet, SSD, YOLOv3, and Faster R-CNN rely on pre-defined anchor boxes. In contrast, our proposed detector FCOS is anchor box free, as well as proposal free. By eliminating the predefined set of anchor boxes, FCOS completely avoids the complicated computation related to anchor boxes such as calculating overlapping during training. More importantly, we also avoid all hyper-parameters related to anchor boxes, which are often very sensitive to the final detection performance. With the only post-processing non-maximum suppression (NMS), FCOS with ResNeXt-64x4d-101 achieves 44.7% in AP with single-model and single-scale testing, surpassing previous one-stage detectors with the advantage of being much simpler. For the first time, we demonstrate a much simpler and flexible detection framework achieving improved detection accuracy. We hope that the proposed FCOS framework can serve as a simple and strong alternative for many other instance-level tasks. Code is available at:Code is available at: https://tinyurl.com/FCOSv1

For agents

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

get_harvested_code_for_paper("1904.01355")
get_code_for_paper("1904.01355")
have("1904.01355")

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

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

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

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

Connect an agent — have() is free.