SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1703.07402 · 2017

Simple Online and Realtime Tracking with a Deep Association Metric

arXiv · PDF · Open in the Atlas

Code that ran

29 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; 8 honoured the contract we drafted, 3 violated it and 3 have no contract verdict; 15 failures of our instrument; 11 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/1703.07402.json · badge: /api/ran/1703.07402.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
nadee13/deep_sort_project canonical (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
ZQPei/deep_sort_pytorch community (classifier label)
classifier basis not recorded on the link
7 ran · 3 no recorded run
pvtien96/D2DP community (classifier label)
classifier basis not recorded on the link
5 ran · 1 no recorded run
levan92/deep_sort_realtime community (classifier label)
classifier basis not recorded on the link
4 ran · 2 no recorded run
knorth55/chainer-sort community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
mikel-brostrom/Yolov3_DeepSort_Pytorch extension (classifier label)
classifier basis: classifier_2025
2 ran · 1 no recorded run
htso/Pedestrian_in_few_shots extension (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
rechardchen123/Crowded_analysis community (classifier label)
classifier basis not recorded on the link
1 ran · 1 no recorded run
RunzhaoHuang/DeepSort_YOLOV5_OnScreen extension (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
kshitij1489/object-tracking extension (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
GeekAlexis/Constrained-Object-Tracking community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
wy-moonind/trackrcnn_with_deepsort extension (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
bbednarski9/MaskTrackRCNN_DeepSort extension (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
WuPedin/Multi-class_Yolov5_DeepSort_Pytorch extension (classifier label)
classifier basis: classifier_2025
0 ran · 1 no recorded run
derek285/yolov4_deep_sort_pytorch community (classifier label)
classifier basis not recorded on the link
0 ran · 1 no recorded run
FunctionStatusWhere it lives
DWConv Ran
ran; our contract draft was wrong, not the code
pvtien96/D2DP/models/common.py
code served (permissive licence) · get_code("59a62915f41f0ae3")
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 Conv. 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)

# DWConv signature: DWConv(c1, c2, k=1, s=1, act=True)
# c1: input channels
# c2: output channels
# k: kernel size (default 1)
# s: stride (default 1)
# act: whether to use activation (default True)

ARGS = {
    'c1': 3,
    'c2': 16,
    'k': 3,
    's': 1,
    'act': 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 Conv — a Conv output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv 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
autopad Ran
ran, honoured the contract we drafted
pvtien96/D2DP/models/common.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from yang-0201/YOLOv6_pro, is pointer only (licence: GPL-3.0) · get_code("988a3c854b1b13d0")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from yang-0201/YOLOv6_pro, and GPL-3.0, as GitHub detects it on that repository, is not in the permissive set Syntology serves inline. 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.

bbox2z_bbox Ran
ran, honoured the contract we drafted
knorth55/chainer-sort/chainer_sort/utils.py
code served (permissive licence) · get_code("f0cdb54625556b73")
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 bbox array with shape (2, 4)
# bbox format: [y1, x1, y2, x2] for each bounding box
bbox = np.array([
    [10.0, 20.0, 50.0, 80.0],
    [15.0, 25.0, 60.0, 90.0]
], dtype=np.float32)

ARGS = {
    "bbox": bbox
}
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
bbox_rel Ran
ran, violated the contract we drafted
mikel-brostrom/Yolov3_DeepSort_Pytorch/track.py
pointer only (licence: NONE) · get_code("5e8762674f3d125a")
How it ran

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

bool_string Ran
ran, violated the contract we drafted
nadee13/deep_sort_project/deep_sort_app.py
pointer only (licence: GPL-3.0) · get_code("23391005ce4422ba")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, nadee13/deep_sort_project, is not in the permissive set Syntology serves inline. 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.

calc_extended_coordinates Ran
ran, honoured the contract we drafted
htso/Pedestrian_in_few_shots/generate_MOT_data.py
code served (permissive licence) · get_code("b712a668b08fcef4")
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 tuple, ndim 1, dtype family int; 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)

# The function takes x, y, h, w, aspect_ratio as parameters
# These appear to be bounding box coordinates and dimensions for a pedestrian image
# x, y are top-left coordinates
# h, w are height and width
# aspect_ratio is a positive float

x = 10
y = 20
h = 100
w = 50
aspect_ratio = 2.0

ARGS = {
    'x': x,
    'y': y,
    'h': h,
    'w': w,
    'aspect_ratio': aspect_ratio
}
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 tuple, ndim 1, dtype family int — a tuple 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
compute_color_for_labels Ran
ran, honoured the contract we drafted
RunzhaoHuang/DeepSort_YOLOV5_OnScreen/tracking_on_screen(trajectory).py
pointer only (licence: NONE) · get_code("364de74123ec7072")
How it ran

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

compute_color_for_labels Ran
ran, honoured the contract we drafted
mikel-brostrom/Yolov3_DeepSort_Pytorch/track.py
pointer only (licence: NONE) · get_code("bcfa4cf98c4b792a")
How it ran

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

conv_1x1_bn Ran
ran; our contract draft was wrong, not the code
levan92/deep_sort_realtime/deep_sort_realtime/embedder/mobilenetv2_bottle.py
pointer only (licence: MIT); the stored copy get_code serves, from zhoudaquan/rethinking_bottleneck_design, is pointer only (licence: NOASSERTION) · get_code("a0131fb70c267a9e")
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 zhoudaquan/rethinking_bottleneck_design, and GitHub could not classify the licence of that repository (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.

conv_bn Ran
ran; our contract draft was wrong, not the code
levan92/deep_sort_realtime/deep_sort_realtime/embedder/mobilenetv2_bottle.py
code served (permissive licence) · get_code("e087cbfa1e53486d")
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 Sequential. 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 = {
    "inp": 3,
    "oup": 16,
    "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 Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 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
gather_sequence_info Ran
ran; our contract draft was wrong, not the code
kshitij1489/object-tracking/deep_sort/deep_sort_app.py
pointer only (licence: NONE) · get_code("9f48d0757e6d0ed3")
How it ran

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

get_label_name Ran
ran; our contract draft was wrong, not the code
GeekAlexis/Constrained-Object-Tracking/fastmot/models/label.py
code served (permissive licence) · get_code("0d55de58947a5ebd")
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 str. 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

# The function get_label_name takes a class_id parameter and returns the corresponding label name from _label_map
# It simply indexes into a tuple, so class_id should be an integer within the valid range [0, len(_label_map))

ARGS = {
    'class_id': 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
iou Ran
ran on a synthesized input
ZQPei/deep_sort_pytorch/deep_sort/sort/iou_matching.py
code served (permissive licence) · get_code("cd5390257debcfd6")
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 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 numpy as np

# Create a bounding box in format (top left x, top left y, width, height)
bbox = np.array([10.0, 20.0, 30.0, 40.0])

# Create candidate bounding boxes (multiple boxes, same format)
candidates = np.array([
    [12.0, 22.0, 25.0, 35.0],
    [5.0, 15.0, 50.0, 50.0],
])

ARGS = {
    "bbox": bbox,
    "candidates": candidates,
}
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 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
iou_cost Ran
ran on a synthesized input
ZQPei/deep_sort_pytorch/deep_sort/sort/iou_matching.py
code served (permissive licence) · get_code("fa2c5a05698eba02")
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, 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 numpy as np

class MockTrack:
    def __init__(self, tlwh, time_since_update=0):
        self.tlwh_val = tlwh
        self.time_since_update = time_since_update
    
    def to_tlwh(self):
        return self.tlwh_val

class MockDetection:
    def __init__(self, tlwh):
        self.tlwh = tlwh

class MockLinearAssignment:
    INFTY_COST = 1e5

linear_assignment = MockLinearAssignment()

tracks = [
    MockTrack(np.array([10.0, 20.0, 50.0, 100.0]), time_since_update=0),
    MockTrack(np.array([15.0, 25.0, 60.0, 110.0]), time_since_update=0),
]

detections = [
    MockDetection(np.array([12.0, 22.0, 55.0, 105.0])),
    MockDetection(np.array([100.0, 200.0, 40.0, 80.0])),
    MockDetection(np.array([20.0, 30.0, 50.0, 100.0])),
]

ARGS = {
    "tracks": tracks,
    "detections": detections,
    "track_indices": None,
    "detection_indices": 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, 3) — shape (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
iou_cost Ran
ran, honoured the contract we drafted
levan92/deep_sort_realtime/deep_sort_realtime/deep_sort/iou_matching.py
code served (permissive licence) · get_code("15c048b19e9accdc")
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, 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 numpy as np

class MockTrack:
    def __init__(self, ltwh, time_since_update=0):
        self._ltwh = ltwh
        self.time_since_update = time_since_update
    
    def to_ltwh(self):
        return self._ltwh

class MockDetection:
    def __init__(self, ltwh):
        self.ltwh = ltwh

class MockLinearAssignment:
    INFTY_COST = 1e5

linear_assignment = MockLinearAssignment()

tracks = [
    MockTrack(np.array([10.0, 20.0, 50.0, 60.0]), time_since_update=0),
    MockTrack(np.array([100.0, 150.0, 40.0, 50.0]), time_since_update=0),
]

detections = [
    MockDetection(np.array([12.0, 22.0, 48.0, 58.0])),
    MockDetection(np.array([200.0, 250.0, 30.0, 40.0])),
]

ARGS = {
    "tracks": tracks,
    "detections": detections,
    "track_indices": None,
    "detection_indices": 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, 2) — shape (2, 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
isaobject Ran
ran, violated the contract we drafted
wy-moonind/trackrcnn_with_deepsort/forwarding/tracking/tracking_deepsort/deep_sort_app.py
code served (permissive licence) · get_code("a1d65be3da633121")
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

# The function checks if t_i is in t1 using the 'in' operator
# This works for checking if an element is in a collection (list, set, tuple, dict keys, string, etc.)

# Simple case: t_i is an element, t1 is a list
t_i = 5
t1 = [1, 2, 3, 4, 5, 6, 7]

ARGS = {
    't_i': t_i,
    't1': t1
}
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
letterbox Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
pvtien96/D2DP/detection_helpers.py
code served (permissive licence) · get_code("67b6bcd432280615")
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 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 cv2
import numpy as np

# Create a small test image (4x3 BGR image with uint8 dtype)
img = np.random.randint(0, 256, size=(4, 3, 3), dtype=np.uint8)

ARGS = {
    'img': img,
    'new_shape': (640, 640),
    'color': (114, 114, 114),
    'auto': True,
    'scale_fill': False,
    'scale_up': True,
}
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 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: none by the harness; any seed is in the setup block
make_layers Ran
ran on a synthesized input
ZQPei/deep_sort_pytorch/deep_sort/deep/model.py
code served (permissive licence) · get_code("c0b3d0e6e5a858ad")
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 Sequential. 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 = {
    "c_in": 3,
    "c_out": 64,
    "repeat_times": 2,
    "is_downsample": 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 Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 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
merge_image Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
htso/Pedestrian_in_few_shots/generate_MOT_data.py
code served (permissive licence) · get_code("b519b3091a2adc36")
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 ndarray, ndim 3, dtype family float, shape (5, 6, 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 numpy as np

# Create two small RGB images with different shapes
# img1: 5x4x3 (height=5, width=4, channels=3)
# img2: 3x6x3 (height=3, width=6, channels=3)

img1 = np.random.rand(5, 4, 3)
img2 = np.random.rand(3, 6, 3)

ARGS = {
    'img1': img1,
    'img2': img2
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
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 3, dtype family float, shape (5, 6, 3) — shape (5, 6, 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
min_cost_matching Ran
ran; our contract draft was wrong, not the code
ZQPei/deep_sort_pytorch/deep_sort/sort/linear_assignment.py
code served (permissive licence) · get_code("0a742086c6efe7cd")
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 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 numpy as np

class Track:
    """Minimal Track class for testing"""
    def __init__(self, track_id, state):
        self.track_id = track_id
        self.state = state

class Detection:
    """Minimal Detection class for testing"""
    def __init__(self, detection_id, feature):
        self.detection_id = detection_id
        self.feature = feature

def distance_metric_fn(tracks, detections, track_indices, detection_indices):
    """
    Compute cost matrix between tracks and detections.
    Returns NxM matrix where N=len(track_indices), M=len(detection_indices)
    """
    n_tracks = len(track_indices)
    n_detections = len(detection_indices)
    
    # Create a simple cost matrix based on feature distance
    cost_matrix = np.zeros((n_tracks, n_detections))
    
    for i, track_idx in enumerate(track_indices):
        track = tracks[track_idx]
        for j, det_idx in enumerate(detection_indices):
            detection = detections[det_idx]
            # Simple Euclidean distance between track state and detection feature
            cost_matrix[i, j] = np.linalg.norm(track.state - detection.feature)
    
    return cost_matrix

# Create sample tracks
tracks = [
    Track(0, np.array([1.0, 2.0, 3.0, 4.0])),
    Track(1, np.array([2.0, 3.0, 4.0, 5.0])),
]

# Create sample detections
detections = [
    Detection(0, np.array([1.1, 2.1, 3.1, 4.1])),
    Detection(1, np.array([5.0, 6.0, 7.0, 8.0])),
    Detection(2, np.array([2.0, 3.0, 4.0, 5.0])),
]

ARGS = {
    "distance_metric": distance_metric_fn,
    "max_distance": 2.0,
    "tracks": tracks,
    "detections": detections,
    "track_indices": None,
    "detection_indices": None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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: none by the harness; any seed is in the setup block
min_cost_matching Ran
ran; our contract draft was wrong, not the code
levan92/deep_sort_realtime/deep_sort_realtime/deep_sort/linear_assignment.py
code served (permissive licence) · get_code("8304785457f11883")
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 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 numpy as np

# Define simple stand-in classes for Track and Detection
class Track:
    def __init__(self, track_id):
        self.track_id = track_id

class Detection:
    def __init__(self, detection_id):
        self.detection_id = detection_id

# Define a distance metric function that returns an NxM cost matrix
def distance_metric(tracks, detections, track_indices, detection_indices):
    """
    Compute cost matrix between tracks and detections.
    Returns an NxM matrix where N = len(track_indices) and M = len(detection_indices)
    """
    n_tracks = len(track_indices)
    n_detections = len(detection_indices)
    # Create a simple cost matrix with distinct values
    cost_matrix = np.random.rand(n_tracks, n_detections) * 10
    return cost_matrix

# Create sample data
tracks = [Track(i) for i in range(3)]
detections = [Detection(j) for j in range(4)]

ARGS = {
    "distance_metric": distance_metric,
    "max_distance": 5.0,
    "tracks": tracks,
    "detections": detections,
    "track_indices": None,
    "detection_indices": None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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: none by the harness; any seed is in the setup block
resnet18 Ran
ran; our contract draft was wrong, not the code
ZQPei/deep_sort_pytorch/deep_sort/deep/resnet.py
code served (permissive licence) · get_code("79ac771d6b3a68cb")
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

torch.manual_seed(0)

ARGS = {
    "num_classes": 10,
    "reid": 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
ZQPei/deep_sort_pytorch/deep_sort/deep/resnet.py
code served (permissive licence) · get_code("62d58b0f4a8594d6")
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

torch.manual_seed(0)

ARGS = {
    "num_classes": 10,
    "reid": 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
resnet50 Ran
ran; our contract draft was wrong, not the code
ZQPei/deep_sort_pytorch/deep_sort/deep/resnet.py
code served (permissive licence) · get_code("74b64443e8b81859")
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

torch.manual_seed(0)

ARGS = {
    "num_classes": 10,
    "reid": 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
scale_coords Ran
ran; our contract draft was wrong, not the code
pvtien96/D2DP/detection_helpers.py
code served (permissive licence) · get_code("cc9d47d5d287438a")
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)

# Create a small batch of bounding box coordinates (format: x1, y1, x2, y2)
coords = torch.tensor([
    [10.0, 20.0, 100.0, 150.0],
    [50.0, 60.0, 200.0, 250.0]
], dtype=torch.float32)

# New shape that the coordinates were scaled to (height, width)
new_shape = (640, 480)

# Original shape of the image (height, width)
original_shape = (480, 360)

# ratio_pad can be None or a tuple of (gain, pad)
ratio_pad = None

ARGS = {
    "coords": coords,
    "new_shape": new_shape,
    "original_shape": original_shape,
    "ratio_pad": ratio_pad
}
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
single_frame Ran
ran; our contract draft was wrong, not the code
bbednarski9/MaskTrackRCNN_DeepSort/tools/test_video_live.py
code served (permissive licence) · get_code("1bc1d9b92dfee6c1")
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 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.utils.data import Dataset, DataLoader

torch.manual_seed(0)

class MockDataset(Dataset):
    def __init__(self):
        self.CLASSES = ['class1', 'class2', 'class3']
        self.img_norm_cfg = {
            'mean': [123.675, 116.28, 103.53],
            'std': [58.395, 57.12, 57.375],
            'to_rgb': True
        }
    
    def __len__(self):
        return 3
    
    def __getitem__(self, idx):
        return {
            'img': torch.randn(3, 8, 12),
            'img_metas': [{'filename': f'img_{idx}.jpg'}]
        }

class MockModule(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(3, 4, 3, padding=1)
    
    def forward(self, img, img_metas, return_loss=True, rescale=True, **kwargs):
        # Return mock detection results
        return {
            'bbox_results': torch.randn(5, 5),
            'segm_results': None
        }
    
    def show_result_demo(self, data, result, img_norm_cfg, dataset=None, 
                        save_vis=False, save_path='', is_video=False, 
                        save_path_alt=False, save_name_alt=None, color_image=None):
        # Return a mock blended image
        return torch.randn(8, 12, 3)

class MockModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.module = MockModule()
    
    def eval(self):
        return self
    
    def __call__(self, img, img_metas, return_loss=True, rescale=True, **kwargs):
        return self.module(img, img_metas, return_loss=return_loss, rescale=rescale, **kwargs)

def collate_fn(batch):
    return batch[0]

dataset = MockDataset()
data_loader = DataLoader(dataset, batch_size=1, collate_fn=collate_fn)
model = MockModel()

ARGS = {
    'model': model,
    'data_loader': data_loader,
    'show': True,
    'save_path': '/tmp/output',
    'save_name_alt': 'frame_001',
    'color_image': torch.randn(8, 12, 3)
}
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 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: none by the harness; any seed is in the setup block
unique_config_sections Ran
ran; our contract draft was wrong, not the code
rechardchen123/Crowded_analysis/convert.py
code served (permissive licence) · get_code("4263a5b87ed0d942")
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 StringIO. 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 io
import tempfile
import os
from collections import defaultdict

# Create a temporary config file with duplicate section names
temp_config_content = """[section1]
key1=value1

[section1]
key2=value2

[section2]
key3=value3

[section1]
key4=value4

[section2]
key5=value5
"""

# Write to a temporary file
with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.cfg') as f:
    f.write(temp_config_content)
    temp_config_file = f.name

try:
    ARGS = {
        'config_file': temp_config_file
    }
finally:
    # Clean up after defining ARGS (the file will be used during function execution)
    pass
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type StringIO — a StringIO 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
xyxy2xywh Ran
ran, honoured the contract we drafted
pvtien96/D2DP/detection_helpers.py
code served (permissive licence) · get_code("06012c3cd55c5561")
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
import numpy as np

torch.manual_seed(0)

# The function xyxy2xywh converts bounding boxes from xyxy format 
# (x1, y1, x2, y2) to xywh format (center_x, center_y, width, height)
# It accepts either torch.Tensor or numpy.ndarray

# Create a small test tensor with shape (2, 4) - 2 bounding boxes with 4 coordinates each
x_torch = torch.tensor([
    [10.0, 20.0, 50.0, 80.0],
    [5.0, 15.0, 35.0, 65.0]
], dtype=torch.float32)

ARGS = {
    "x": x_torch
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, 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
z_bbox2bbox Ran
ran, honoured the contract we drafted
knorth55/chainer-sort/chainer_sort/utils.py
code served (permissive licence) · get_code("5d03f860ed96c18d")
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 sample z_bbox array
# z_bbox should have shape (batch_size, 4)
# Each row contains: [center_y, center_x, area, aspect_ratio]
batch_size = 2
z_bbox = np.array([
    [10.0, 20.0, 100.0, 2.0],  # center_y=10, center_x=20, area=100, aspect_ratio=2
    [15.0, 25.0, 50.0, 1.0],   # center_y=15, center_x=25, area=50, aspect_ratio=1
], dtype=np.float32)

ARGS = {
    "z_bbox": z_bbox
}
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
bbox_rel Not yet run
unverified (harvested, no recorded run)
WuPedin/Multi-class_Yolov5_DeepSort_Pytorch/track.py
pointer only (licence: NONE) · get_code("4d17ebc44dfba307")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, WuPedin/Multi-class_Yolov5_DeepSort_Pytorch 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. No invocation recorded.

detectron2 Not yet run
unverified (harvested, no recorded run)
pvtien96/D2DP/dt2ds.py
code served (permissive licence) · get_code("4b4a656d2b730d15")
How it ran

no invocation recorded.

draw_boxes Not yet run
unverified (harvested, no recorded run)
mikel-brostrom/Yolov3_DeepSort_Pytorch/track.py
pointer only (licence: NONE) · get_code("59436e1976fca4d6")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, mikel-brostrom/Yolov3_DeepSort_Pytorch 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. No invocation recorded.

gate_cost_matrix Not yet run
unverified (harvested, no recorded run)
ZQPei/deep_sort_pytorch/deep_sort/sort/linear_assignment.py
code served (permissive licence) · get_code("fd534ce01d39359c")
How it ran

no invocation recorded.

get_mobilenetv2_with_preproc Not yet run
unverified (harvested, no recorded run)
levan92/deep_sort_realtime/deep_sort_realtime/embedder/embedder_tf.py
code served (permissive licence) · get_code("dc21eca25ed9cb47")
How it ran

no invocation recorded.

load_gt Not yet run
unverified (harvested, no recorded run)
knorth55/chainer-sort/chainer_sort/datasets/mot/mot_utils.py
code served (permissive licence) · get_code("9b012aa5b8cac324")
How it ran

no invocation recorded.

matching_cascade Not yet run
unverified (harvested, no recorded run)
ZQPei/deep_sort_pytorch/deep_sort/sort/linear_assignment.py
code served (permissive licence) · get_code("678c3011c5eeafdc")
How it ran

no invocation recorded.

matching_cascade Not yet run
unverified (harvested, no recorded run)
levan92/deep_sort_realtime/deep_sort_realtime/deep_sort/linear_assignment.py
code served (permissive licence) · get_code("7c1e16a99a918566")
How it ran

no invocation recorded.

non_max_suppression Not yet run
unverified (harvested, no recorded run)
derek285/yolov4_deep_sort_pytorch/deep_sort/sort/preprocessing.py
code served (permissive licence) · get_code("e8fe9fcc53566f61")
How it ran

no invocation recorded.

project_w2c Not yet run
unverified (harvested, no recorded run)
rechardchen123/Crowded_analysis/camera_calibrate.py
code served (permissive licence) · get_code("50c344398389f116")
How it ran

no invocation recorded.

read_split_data Not yet run
unverified (harvested, no recorded run)
ZQPei/deep_sort_pytorch/deep_sort/deep/datasets.py
code served (permissive licence) · get_code("5b2e3d40787b847d")
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 39 distinct functions with an identity, 16 are also present in other papers whose code we hold (3 with at least one paper dated earlier, 0 the same month, 16 later) and 23 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
conv_1x1_bn 31 other papers
31 later · 2 only as an assembly brick
1801.04381 (2018-01)
MobileNetV2: Inverted Residuals and Linear Bottlenecks
1811.08383 (2018-11)
TSM: Temporal Shift Module for Efficient Video Understanding
1812.00332 (2018-12)
ProxylessNAS: Direct Neural Architecture Search on Target Task and Hardware
and 28 more not named here
autopad 23 other papers
1 dated earlier, 22 later · 1 only as an assembly brick
1311.2524 (2013-11)
Rich feature hierarchies for accurate object detection and semantic segmentation
1804.02767 (2018-04)
YOLOv3: An Incremental Improvement
1902.03368 (2019-02)
Skin Lesion Analysis Toward Melanoma Detection 2018: A Challenge Hosted by the International Skin Imaging Collaboration (ISIC)
and 20 more not named here
conv_bn 18 other papers
1 dated earlier, 17 later · 1 only as an assembly brick
1611.06403 (2016-11)
Deep Outdoor Illumination Estimation
1801.04381 (2018-01)
MobileNetV2: Inverted Residuals and Linear Bottlenecks
1811.08383 (2018-11)
TSM: Temporal Shift Module for Efficient Video Understanding
and 15 more not named here
DWConv 6 other papers
6 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2206.14651 (2022-06)
BoT-SORT: Robust Associations Multi-Pedestrian Tracking
2207.02696 (2022-07)
YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors
and 3 more not named here
unique_config_sections 5 other papers
1 dated earlier, 4 later
1612.08242 (2016-12)
YOLO9000: Better, Faster, Stronger
1710.10891 (2017-10)
Open Set Logo Detection and Retrieval
1804.02767 (2018-04)
YOLOv3: An Incremental Improvement
and 2 more not named here
make_layers 4 other papers
4 later
1904.07850 (2019-04)
Objects as Points
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2110.06864 (2021-10)
ByteTrack: Multi-Object Tracking by Associating Every Detection Box
and 1 more not named here
non_max_suppression 3 other papers
3 later
1902.03748 (2019-02)
Peeking into the Future: Predicting Future Person Activities and Locations in Videos
2002.08397 (2020-02)
JRMOT: A Real-Time 3D Multi-Object Tracker and a New Large-Scale Dataset
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
compute_color_for_labels 2 other papers
2 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2202.13514 (2022-02)
StrongSORT: Make DeepSORT Great Again
draw_boxes 2 other papers
2 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2202.13514 (2022-02)
StrongSORT: Make DeepSORT Great Again
gate_cost_matrix 2 other papers
2 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2202.13514 (2022-02)
StrongSORT: Make DeepSORT Great Again
iou 2 other papers
2 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2202.13514 (2022-02)
StrongSORT: Make DeepSORT Great Again
iou_cost 2 other papers
2 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2202.13514 (2022-02)
StrongSORT: Make DeepSORT Great Again
bbox_rel 1 other paper
1 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
matching_cascade 1 other paper
1 later
2202.13514 (2022-02)
StrongSORT: Make DeepSORT Great Again
single_frame 1 other paper
1 later
1905.04804 (2019-05)
Video Instance Segmentation
xyxy2xywh 1 other paper
1 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection

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

Simple Online and Realtime Tracking (SORT) is a pragmatic approach to multiple object tracking with a focus on simple, effective algorithms. In this paper, we integrate appearance information to improve the performance of SORT. Due to this extension we are able to track objects through longer periods of occlusions, effectively reducing the number of identity switches. In spirit of the original framework we place much of the computational complexity into an offline pre-training stage where we learn a deep association metric on a large-scale person re-identification dataset. During online application, we establish measurement-to-track associations using nearest neighbor queries in visual appearance space. Experimental evaluation shows that our extensions reduce the number of identity switches by 45%, achieving overall competitive performance at high frame rates.

For agents

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

get_harvested_code_for_paper("1703.07402")
get_code_for_paper("1703.07402")
have("1703.07402")

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

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

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

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

Connect an agent — have() is free.