SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1911.10033 · 2019

Domain Adaptation for Object Detection via Style Consistency

arXiv · PDF · Open in the Atlas

Code that ran

11 of 13 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; 0 honoured the contract we drafted, 1 violated it and 5 have no contract verdict; 5 failures of our instrument; 2 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/1911.10033.json · badge: /api/ran/1911.10033.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
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency community (classifier label)
classifier basis not recorded on the link
11 ran · 2 no recorded run
FunctionStatusWhere it lives
adaptive_instance_normalization Ran
ran; our contract draft was wrong, not the code
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/styletransfer.py
code served (permissive licence) · get_code("16679a24b9881031")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 4, dtype family float, shape (2, 4, 3, 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 torch
import torch.nn as nn

torch.manual_seed(0)

# Create small 4D tensors for content and style features
# Shape: (N, C, H, W) where N=batch, C=channels, H=height, W=width
# Using distinct sizes: batch=2, channels=4, height=3, width=5
content_feat = torch.randn(2, 4, 3, 5)
style_feat = torch.randn(2, 4, 3, 5)

ARGS = {
    "content_feat": content_feat,
    "style_feat": style_feat,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 3, 5) — shape (2, 4, 3, 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
add_extras Ran
ran; our contract draft was wrong, not the code
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/models/vgg_ssd.py
code served (permissive licence) · get_code("2a8545e480332b47")
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 torch.nn as nn

torch.manual_seed(0)

# The function expects:
# - cfg: a list/tuple that can contain integers and 'S' strings
# - i: an integer representing initial in_channels
# - batch_norm: a boolean (default False)

# Looking at the function logic:
# - It iterates over cfg with enumerate
# - cfg elements can be 'S' or integers (representing out_channels)
# - When v == 'S', it looks at cfg[k+1] for the next value
# - in_channels starts as i and gets updated to v in each iteration
# - flag alternates between False and True to choose kernel_size (1 or 3)

# A valid cfg would be a list with integers and 'S' markers
# Example: [256, 'S', 512, 128, 'S', 256, 128]
# This means: 
# - First layer: in_channels=i, out_channels=256, kernel_size=1
# - Second layer: in_channels=256, out_channels=512 (from cfg[k+1]), kernel_size=3, stride=2
# - Third layer: in_channels=512, out_channels=128, kernel_size=1
# - Fourth layer: in_channels=128, out_channels=256 (from cfg[k+1]), kernel_size=3, stride=2
# - Fifth layer: in_channels=256, out_channels=128, kernel_size=1

cfg = [256, 'S', 512, 128, 'S', 256, 128]
i = 1024
batch_norm = False

ARGS = {
    'cfg': cfg,
    'i': i,
    'batch_norm': batch_norm
}
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 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
boxes_from_dets Ran
ran on a synthesized input
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/trainer.py
code served (permissive licence) · get_code("c73f130d6db094a7")
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 torch

torch.manual_seed(0)

# The function expects detections tensor with shape:
# (batch_size, num_classes+1, num_boxes, 5)
# where each box has [score, x1, y1, x2, y2]
# cidx ranges from 1 to detections.size(1), so we need at least 2 in that dimension
# The function accesses detections[bidx, cidx, :, 0] for scores and detections[bidx, cidx, :, 1:] for bboxes

batch_size = 2
num_classes_plus_1 = 4  # Will iterate cidx from 1 to 3
num_boxes = 6
box_data_size = 5  # score + 4 bbox coords

# Create detection tensor: (batch, classes+1, boxes, 5)
detections = torch.rand(batch_size, num_classes_plus_1, num_boxes, box_data_size)
# Scale scores to be between 0 and 1 for meaningful thresholding
detections[:, :, :, 0] = torch.rand(batch_size, num_classes_plus_1, num_boxes)

ARGS = {
    "detections": detections,
    "thresh": 0.25
}
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 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
calc_mean_std Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/styletransfer.py
code served (permissive licence) · get_code("38eaf8511dc7bc9c")
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 tuple, ndim 5, 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)

# The function expects a 4D tensor (N, C, H, W)
# N = batch size, C = channels, H = height, W = width
# Using distinct sizes: batch=2, channels=4, height=3, width=5
feat = torch.randn(2, 4, 3, 5)

ARGS = {
    "feat": feat,
    "eps": 1e-05
}
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 tuple, ndim 5, dtype family float — 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
coral Ran
ran on a synthesized input
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/styletransfer.py
code served (permissive licence) · get_code("cbfcc224a2f63e72")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (3, 4, 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 torch

torch.manual_seed(0)

# The function expects two tensors with shape [3, ...] where the first dimension is 3
# Looking at the function body:
# - feat.size()[0] == 3 (asserted)
# - feat is reshaped to (3, -1) via view
# - Operations use mean/std across the flattened dimension
# - Returns a tensor with same shape as input

# Create two feature tensors with shape [3, 4, 5] (3 channels, 4x5 spatial)
source = torch.randn(3, 4, 5)
target = torch.randn(3, 4, 5)

ARGS = {
    "source": source,
    "target": target,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (3, 4, 5) — shape (3, 4, 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
draw_annos Ran
ran on a synthesized input
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/pseudolabel.py
code served (permissive licence) · get_code("b6fbfd91fcc7875e")
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 Image. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from PIL import Image, ImageDraw

torch.manual_seed(0)

# Create a small test image
image = Image.new('RGB', (320, 240), color='white')

# Create annotations as a tensor
# Each annotation: [x1, y1, x2, y2, class_id]
# Using normalized coordinates (0-1 range) and class_ids 1-20
annos = torch.tensor([
    [0.1, 0.1, 0.3, 0.3, 1],      # aeroplane
    [0.5, 0.5, 0.8, 0.8, 15],     # person
], dtype=torch.float32)

colour = (0, 0, 255)

ARGS = {
    'image': image,
    'annos': annos,
    'colour': colour
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 and dtype family int 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
draw_annos Ran
ran on a synthesized input
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/visualize_pseudolabels.py
code served (permissive licence) · get_code("7deb45fa5fc536b1")
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 Image. 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.

from PIL import Image
import numpy as np

# Create a small test image (RGB mode, 100x80 pixels)
image = Image.new('RGB', (100, 80), color=(255, 255, 255))

# Create annotations list
# Each annotation is [x1, y1, x2, y2, class_id]
# Using normalized coordinates (0-1 range) for some, pixel coordinates for others
annos = [
    [0.1, 0.2, 0.5, 0.6, 0],      # normalized coords, class 0 (aeroplane)
    [10, 15, 40, 50, 14],          # pixel coords, class 14 (person)
    [0.6, 0.3, 0.9, 0.7, 6],       # normalized coords, class 6 (car)
]

colour = (255, 0, 0)  # Red

ARGS = {
    'image': image,
    'annos': annos,
    'colour': colour
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 and dtype family int 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
get_output_dir Ran
ran on a synthesized input
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/visualise_detections.py
code served (permissive licence) · get_code("af7b48f3521d73e9")
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 os
import tempfile

# Create a temporary directory for testing
test_dir = tempfile.mkdtemp()

# Define the arguments for get_output_dir
ARGS = {
    "dir_path": os.path.join(test_dir, "output_artifacts")
}
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 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
multibox Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/models/vgg_ssd.py
code served (permissive licence) · get_code("b490ac8699f5a7ad")
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

torch.manual_seed(0)

# First, we need to create a VGG configuration and build the vgg layers
vgg_cfg = [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'C', 512, 512, 512, 'M', 512, 512, 512]

def vgg(cfg, i, batch_norm=False):
    layers = []
    in_channels = i
    for v in cfg:
        if v == 'M':
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        elif v == 'C':
            layers += [nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)]
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            if batch_norm:
                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
            else:
                layers += [conv2d, nn.ReLU(inplace=True)]
            in_channels = v
    pool5 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
    conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)
    conv7 = nn.Conv2d(1024, 1024, kernel_size=1)
    layers += [pool5, conv6, nn.ReLU(inplace=True), conv7, nn.ReLU(inplace=True)]
    return layers

# Build vgg layers
vgg_layers = vgg(vgg_cfg, 3, batch_norm=False)

# Create extra_layers - these should be conv layers with out_channels attribute
# The function accesses extra_layers[1::2] (every other element starting from index 1)
# and expects them to have .out_channels
extra_layers = [
    nn.Conv2d(1024, 256, kernel_size=1),
    nn.Conv2d(256, 512, kernel_size=3, stride=2, padding=1),
    nn.Conv2d(512, 128, kernel_size=1),
    nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1),
]

# cfg is a list of numbers representing the number of boxes per feature map
# The function expects len(cfg) >= 2 + len(extra_layers[1::2])
# extra_layers[1::2] has length 2, so cfg needs at least 4 elements
cfg = [4, 6, 6, 4]

# num_classes
num_classes = 21

ARGS = {
    'vgg': vgg_layers,
    'extra_layers': extra_layers,
    'cfg': cfg,
    'num_classes': num_classes
}
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
str2bool Ran
ran, violated the contract we drafted
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/visualise_detections.py
code served (permissive licence) · get_code("25c7475539e39da4")
How it ran

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

import torch

def str2bool(v):
    return v.lower() in ('yes', 'true', 't', '1')

ARGS = {
    'v': 'true'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
vgg Ran
ran; our contract draft was wrong, not the code
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/models/vgg_ssd.py
code served (permissive licence) · get_code("6921f7ed00595a4f")
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 torch.nn as nn

torch.manual_seed(0)

# The function expects:
# - cfg: a list/tuple containing integers (number of channels) and strings 'M' or 'C' for pooling
# - i: integer representing input channels
# - batch_norm: boolean flag

# Looking at the function body, cfg is iterated over and can contain:
# - 'M' or 'C' for MaxPool2d layers
# - integers for Conv2d output channels
# The function builds a VGG-style network

# Create a simple configuration
cfg = [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'C', 512, 512, 512, 'M', 512, 512, 512]

# Input channels (typically 3 for RGB images)
i = 3

# Batch normalization flag
batch_norm = False

ARGS = {
    'cfg': cfg,
    'i': i,
    'batch_norm': batch_norm
}
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 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 Not yet run
unverified (harvested, no recorded run)
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/pseudolabel.py
code served (permissive licence) · get_code("3d0d74057d9f5c81")
How it ran

no invocation recorded.

parse_rec Not yet run
unverified (harvested, no recorded run)
pb2377/Pytorch-Domain-Adaptation-via-Style-Consistency/visualise_detections.py
code served (permissive licence) · get_code("a92789866fc1591a")
How it ran

no invocation recorded.

Also present in other papers' code

Of 13 samples lifted from this paper's linked repositories, 13 carry a function identity and 0 do not. Of the 13 distinct functions with an identity, 8 are also present in other papers whose code we hold (7 with at least one paper dated earlier, 1 the same month, 7 later) and 5 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
calc_mean_std 26 other papers
2 dated earlier, 24 later · 4 only as an assembly brick
1703.06868 (2017-03)
Arbitrary Style Transfer in Real-time with Adaptive Instance Normalization
1812.02342 (2018-12)
Arbitrary Style Transfer with Style-Attentional Networks
2003.08436 (2020-03)
Collaborative Distillation for Ultra-Resolution Universal Style Transfer
and 23 more not named here
str2bool 23 other papers
8 dated earlier, 15 later
1410.5401 (2014-10)
Neural Turing Machines
1502.04623 (2015-02)
DRAW: A Recurrent Neural Network For Image Generation
1504.06852 (2015-04)
FlowNet: Learning Optical Flow with Convolutional Networks
and 20 more not named here
adaptive_instance_normalization 12 other papers
1 dated earlier, 11 later
1703.06868 (2017-03)
Arbitrary Style Transfer in Real-time with Adaptive Instance Normalization
2003.08436 (2020-03)
Collaborative Distillation for Ultra-Resolution Universal Style Transfer
2004.10955 (2020-04)
Joint Bilateral Learning for Real-time Universal Photorealistic Style Transfer
and 9 more not named here
vgg 11 other papers
6 dated earlier, 5 later
1409.1556 (2014-09)
Very Deep Convolutional Networks for Large-Scale Image Recognition
1512.02325 (2015-12)
SSD: Single Shot MultiBox Detector
1611.08563 (2016-11)
Online Real-time Multiple Spatiotemporal Action Localisation and Prediction
and 8 more not named here
add_extras 6 other papers
4 dated earlier, 2 later
1512.02325 (2015-12)
SSD: Single Shot MultiBox Detector
1611.08563 (2016-11)
Online Real-time Multiple Spatiotemporal Action Localisation and Prediction
1901.02446 (2019-01)
Panoptic Feature Pyramid Networks
and 3 more not named here
multibox 6 other papers
2 dated earlier, 4 later
1512.02325 (2015-12)
SSD: Single Shot MultiBox Detector
1908.07129 (2019-08)
Zero-Shot Grounding of Objects from Natural Language Queries
1912.03478 (2019-12)
A Real-time Global Inference Network for One-stage Referring Expression Comprehension
and 3 more not named here
parse_rec 2 other papers
1 dated earlier, 1 later
1512.02325 (2015-12)
SSD: Single Shot MultiBox Detector
2006.02158 (2020-06)
Interpolation-based semi-supervised learning for object detection
nms 1 other paper
1 the same month
1911.09070 (2019-11)
EfficientDet: Scalable and Efficient 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

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

Abstract

We propose a domain adaptation approach for object detection. We introduce a two-step method: the first step makes the detector robust to low-level differences and the second step adapts the classifiers to changes in the high-level features. For the first step, we use a style transfer method for pixel-adaptation of source images to the target domain. We find that enforcing low distance in the high-level features of the object detector between the style transferred images and the source images improves the performance in the target domain. For the second step, we propose a robust pseudo labelling approach to reduce the noise in both positive and negative sampling. Experimental evaluation is performed using the detector SSD300 on PASCAL VOC extended with the dataset proposed in arxiv:1803.11365 where the target domain images are of different styles. Our approach significantly improves the state-of-the-art performance in this benchmark.

For agents

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

get_harvested_code_for_paper("1911.10033")
get_code_for_paper("1911.10033")
have("1911.10033")

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

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

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

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

Connect an agent — have() is free.