SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1603.08155 · ECCV · 2016

Perceptual Losses for Real-Time Style Transfer and Super-Resolution

arXiv · PDF · Open in the Atlas

Code that ran

34 of 46 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 19 have no contract verdict; 11 failures of our instrument; 12 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/1603.08155.json · badge: /api/ran/1603.08155.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
ZyoungXu/MoSt-DSA community (classifier label)
classifier basis not recorded on the link
11 ran · 2 no recorded run
MartinBuessemeyer/Artistic-Texture-Control community (classifier label)
classifier basis not recorded on the link
9 ran · 1 no recorded run
abhiskk/fast-neural-style community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
gordicaleksa/pytorch-neural-style-transfer-fast community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
oneTaken/pytorch_fast_style_transfer community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
thatbrguy/Dehaze-GAN community (classifier label)
classifier basis not recorded on the link
1 ran · 5 no recorded run
AloneGu/keras_tf_neural_img community (classifier label)
classifier basis not recorded on the link
1 ran · 2 no recorded run
anjalipemmaraju/styletransfernetwork reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
CYetlanezi/Proyecto-Opti reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
cryu854/FastStyle reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
FunctionStatusWhere it lives
calc_rel_pos Ran
ran on a synthesized input
ZyoungXu/MoSt-DSA/model/encoder.py
code served (permissive licence) · get_code("9c9cf950a1618064")
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 int, shape (16, 16, 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
from einops import rearrange

torch.manual_seed(0)

def calc_rel_pos(n):
    pos = torch.meshgrid(torch.arange(n), torch.arange(n))
    pos = rearrange(torch.stack(pos), 'n i j -> (i j) n')
    rel_pos = pos[None, :] - pos[:, None]
    rel_pos += n - 1
    return rel_pos

ARGS = {
    "n": 4
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, 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 int, shape (16, 16, 2) — shape (16, 16, 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
compute_pj Ran
ran; our contract draft was wrong, not the code
MartinBuessemeyer/Artistic-Texture-Control/helpers/hist_layers.py
code served (permissive licence) · get_code("b5166f5e96ce0061")
How it ran

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

torch.manual_seed(0)

# Analyze the function:
# - x: tensor that gets reshaped to (batch_size, 1, -1) and repeated
# - K: integer for number of basis functions
# - L: scalar parameter for phi_k
# - W: scalar parameter for phi_k

# Create small tensors with distinct dimensions
x = torch.randn(2, 4)  # batch_size=2, feature_dim=4
K = 3  # number of basis functions
L = 1.0  # window width
W = 0.5  # sigmoid width

ARGS = {
    "x": x,
    "K": K,
    "L": L,
    "W": W,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 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
conv Ran
ran; our contract draft was wrong, not the code
ZyoungXu/MoSt-DSA/model/decoder.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from xinjie-q/distributed-dvc, is pointer only (licence: NONE) · get_code("1d13034a9dbf1c2a")
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 xinjie-q/distributed-dvc, 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.

deconv Ran
ran; our contract draft was wrong, not the code
ZyoungXu/MoSt-DSA/model/refine.py
code served (permissive licence) · get_code("23f41c2655d6295a")
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 = {
    'in_planes': 3,
    'out_planes': 64,
    'kernel_size': 4,
    'stride': 2,
    '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 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
default Ran
ran, violated the contract we drafted
ZyoungXu/MoSt-DSA/model/encoder.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from ThomasMrY/VCT, is pointer only (licence: NONE) · get_code("60fff7c3c400d7ff")
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 ThomasMrY/VCT, 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.

downsample Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
ZyoungXu/MoSt-DSA/model/loss.py
code served (permissive licence) · get_code("1f6001e1c3b06556")
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 4, dtype family float, shape (2, 4, 4, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function downsample takes a tensor x and performs spatial downsampling
# by taking every 2nd element along dimensions 2 and 3.
# This suggests x should be a 4D tensor (batch, channels, height, width)

x = torch.randn(2, 4, 8, 6)  # batch=2, channels=4, height=8, width=6

ARGS = {
    'x': x
}
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 4, dtype family float, shape (2, 4, 4, 3) — shape (2, 4, 4, 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
exists Ran
ran, violated the contract we drafted
ZyoungXu/MoSt-DSA/model/encoder.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from ThomasMrY/VCT, is pointer only (licence: NONE) · get_code("aa5486a3650902d8")
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 ThomasMrY/VCT, 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.

from_vgg Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
this paper's copy was not recorded; identical code first harvested from aryan-mann/style-transfer
pointer only; the stored copy get_code serves, from aryan-mann/style-transfer, is pointer only (licence: GPL-3.0) · get_code("79bc8cd94a78aa43")
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.

gauss_kernel Ran
ran, honoured the contract we drafted
ZyoungXu/MoSt-DSA/model/loss.py
code served (permissive licence) · get_code("337a38a7be8077eb")
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 4, dtype family float, shape (3, 1, 5, 5) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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)

device = torch.device('cpu')

ARGS = {
    'channels': 3
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (3, 1, 5, 5) — shape (3, 1, 5, 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
get_dataloader_device Ran
ran on a synthesized input
MartinBuessemeyer/Artistic-Texture-Control/parameter_prediction_network/arbitrary_style_helpers.py
code served (permissive licence) · get_code("b16f733f5e7dbd3b")
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. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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)

class Args:
    def __init__(self, effect=None, num_train_gpus=0):
        self.effect = effect
        self.num_train_gpus = num_train_gpus

ARGS = {
    'args': Args(effect='some_other_effect', num_train_gpus=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
get_individual_syle_weight Ran
ran on a synthesized input
MartinBuessemeyer/Artistic-Texture-Control/helpers/losses.py
code served (permissive licence) · get_code("edbcdd31ce12f58c")
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 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function expects gram_matrices to be an iterable of tensors
# It computes the norm of each gram matrix and averages them
# Gram matrices are typically square matrices representing style features

gram_matrix_1 = torch.randn(4, 4)
gram_matrix_2 = torch.randn(4, 4)
gram_matrix_3 = torch.randn(4, 4)

gram_matrices = [gram_matrix_1, gram_matrix_2, gram_matrix_3]

ARGS = {
    "gram_matrices": gram_matrices
}
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 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_learning_rate Ran
ran on a synthesized input
ZyoungXu/MoSt-DSA/Train_Test_Pipe.py
code served (permissive licence) · get_code("b9306d4374e9d337")
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 float, 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 math
import numpy as np

# Create a minimal args object that has step_per_epoch attribute
class ArgsStandIn:
    def __init__(self):
        self.step_per_epoch = 100

args = ArgsStandIn()

ARGS = {
    'step': 1000,
    'gts_num': 5,
    'strategy': 'ori',
    'base_lr': 0.0002,
    'milestones': [500, 2500],
    'gamma': 0.1,
    'continue_lr': 0.0
}
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 float, 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_logger Ran
ran on a synthesized input
MartinBuessemeyer/Artistic-Texture-Control/parameter_prediction_network/model_helper.py
code served (permissive licence) · get_code("e2b8c34776dbc440")
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 WandbLogger. 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 pytorch_lightning as pl


class Args:
    def __init__(self, disable_logger, project_name, group_name):
        self.disable_logger = disable_logger
        self.project_name = project_name
        self.group_name = group_name


# Case 1: Logger disabled
args_disabled = Args(disable_logger=True, project_name=None, group_name=None)

# Case 2: Logger enabled with valid project name
args_enabled = Args(disable_logger=False, project_name="test-project", group_name="test-group")

ARGS = {
    "args": args_enabled,
    "experiment_name": "test-experiment"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
pytorch_lightning — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type WandbLogger — a WandbLogger output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a WandbLogger 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
get_random_first_stage_params Ran
ran on a synthesized input
MartinBuessemeyer/Artistic-Texture-Control/parameter_prediction_network/arbitrary_style_helpers.py
code served (permissive licence) · get_code("a5dd30e0410ed7ce")
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, 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 random

torch.manual_seed(0)

# The function expects an 'image' parameter
# It accesses image.shape[-2] and image.shape[-1]
# So we need a tensor with at least 2 dimensions
# Using shape (2, 4, 8, 6) - batch=2, channels=4, height=8, width=6

image = torch.randn(2, 4, 8, 6)

ARGS = {
    "image": image
}
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, ndim 1, 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
gram Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
anjalipemmaraju/styletransfernetwork/run_style_transfer.py
pointer only (licence: NONE) · get_code("ae3b7d5b880b9e64")
How it ran

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

gram_matrix Ran
ran; our contract draft was wrong, not the code
abhiskk/fast-neural-style/neural_style/utils.py
pointer only (licence: MIT); the stored copy get_code serves, from davidpengucf/SFDAHPE, is pointer only (licence: NONE) · get_code("430c582cd8bbb1df")
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 davidpengucf/SFDAHPE, 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.

gram_matrix Ran
ran on a synthesized input
MartinBuessemeyer/Artistic-Texture-Control/helpers/losses.py
code served (permissive licence) · get_code("a59f6e63a2e37d46")
How it ran

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

import torch

torch.manual_seed(0)

# The function expects input tensor of shape (a, b, c, d)
# It computes a gram matrix by reshaping to (a, b, c*d) and doing matrix multiply
# The result is normalized by b*c*d

# Create a small 4D tensor with distinct dimensions for probing
# shape: (batch=2, channels=4, height=3, width=5)
input_tensor = torch.randn(2, 4, 3, 5)

ARGS = {
    "input": input_tensor
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 4, 4) — shape (2, 4, 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
init_model_config Ran
ran on a synthesized input
ZyoungXu/MoSt-DSA/config.py
code served (permissive licence) · get_code("d3e4e28233687fe8")
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, 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
from functools import partial

torch.manual_seed(0)

ARGS = {
    'F': 32,
    'lambda_range': 'local',
    'depth': [2, 2, 2, 4]
}
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, ndim 1, 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
l1_loss_ignore_minus_one Ran
ran; our contract draft was wrong, not the code
MartinBuessemeyer/Artistic-Texture-Control/helpers/losses.py
code served (permissive licence) · get_code("cea45c4bac1ccbc2")
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 torch.nn.functional as F

torch.manual_seed(0)

# Create small prediction and target tensors
# prediction: model output, shape (batch=2, features=4)
# target: ground truth, shape (batch=2, features=4)
prediction = torch.randn(2, 4)
target = torch.randn(2, 4)

# Ensure some targets are >= -0.5 and some are < -0.5 to test the mask
target[0, 0] = 0.5  # will be included (>= -0.5)
target[0, 1] = -0.6  # will be masked out (< -0.5)
target[1, 0] = -0.3  # will be included (>= -0.5)
target[1, 1] = -1.0  # will be masked out (< -0.5)

ARGS = {
    "prediction": prediction,
    "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 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
load_image Ran
ran on a synthesized input
gordicaleksa/pytorch-neural-style-transfer-fast/utils/utils.py
code served (permissive licence) · get_code("3827515ddabe45d4")
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 float, shape (100, 150, 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 os
import cv2 as cv
import numpy as np
import tempfile

# Create a temporary directory and a dummy image file
temp_dir = tempfile.mkdtemp()
temp_image_path = os.path.join(temp_dir, 'test_image.png')

# Create a simple dummy image (100x150 RGB image)
dummy_image = np.random.randint(0, 256, (100, 150, 3), dtype=np.uint8)
cv.imwrite(temp_image_path, dummy_image[:, :, ::-1])  # OpenCV uses BGR, so reverse channels

ARGS = {
    'img_path': temp_image_path,
    'target_shape': None
}
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 float, shape (100, 150, 3) — shape (100, 150, 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
load_image Ran
ran on a synthesized input
oneTaken/pytorch_fast_style_transfer/utils.py
code served (permissive licence) · get_code("fad8df79e0e300cc")
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 PngImageFile. 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 tempfile
import os
from PIL import Image

# Create a temporary image file for testing
temp_dir = tempfile.gettempdir()
test_image_path = os.path.join(temp_dir, "test_image.png")

# Create a simple test image (100x100 RGB)
test_img = Image.new('RGB', (100, 100), color='red')
test_img.save(test_image_path)

ARGS = {
    'filename': test_image_path,
    'size': None,
    'scale': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PngImageFile — a PngImageFile output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PngImageFile 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
lrelu Ran
ran on a synthesized input
thatbrguy/Dehaze-GAN/legacy/utils.py
code served (permissive licence) · get_code("f1021e0f87be533e")
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, 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 tensorflow as tf
import numpy as np

# Create a small TensorFlow tensor for testing
# The function expects a tensor-like input that supports tf.maximum operation
ip_tensor = tf.constant([[1.0, -0.5, 2.0, -1.5],
                         [0.3, -0.2, 1.5, -0.8]], dtype=tf.float32)

ARGS = {
    'ip': ip_tensor,
    'leak': 0.2
}
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, 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
normalize Ran
ran, honoured the contract we drafted
CYetlanezi/Proyecto-Opti/utils.py
pointer only (licence: NONE) · get_code("748339aa35abdaf0")
How it ran

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

normalize_batch Ran
ran on a synthesized input
oneTaken/pytorch_fast_style_transfer/utils.py
code served (permissive licence) · get_code("589c69c525831d56")
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 4, dtype family float, shape (2, 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
from torch.autograd import Variable

torch.manual_seed(0)

# The function expects a batch tensor with shape [batch_size, channels, height, width]
# where channels=3 (RGB), and values are in range [0, 255] before normalization
# We use small dimensions: batch=2, channels=3, height=4, width=5

batch = torch.randint(0, 256, (2, 3, 4, 5), dtype=torch.float32)

ARGS = {
    "batch": batch
}
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 4, dtype family float, shape (2, 3, 4, 5) — shape (2, 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
perform_first_stage_painter Ran
ran on a synthesized input
MartinBuessemeyer/Artistic-Texture-Control/effects/arbitrary_style_first_stage.py
code served (permissive licence) · get_code("f43a8f5bb4029f70")
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 4, dtype family float, shape (2, 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
import torch.nn as nn
import torchvision

torch.manual_seed(0)

# Create a minimal painter module that takes an image tensor and returns a tensor
class SimplePainter(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(3, 3, kernel_size=3, padding=1)
    
    def forward(self, x):
        # x is expected to be a tensor, apply convolution
        return self.conv(x)

# Create a tiny image tensor: batch_size=2, channels=3, height=4, width=5
nst_image = torch.randn(2, 3, 4, 5)

# Create painter instance
painter = SimplePainter()

# Set up arguments
ARGS = {
    "nst_image": nst_image,
    "painter": painter,
    "kernel_size": 3,
    "sigma": 1.0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, torchvision — 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, 3, 4, 5) — shape (2, 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
phi_k Ran
ran on a synthesized input
MartinBuessemeyer/Artistic-Texture-Control/helpers/hist_layers.py
code served (permissive licence) · get_code("54e18b1fc47a06a2")
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
from torch import nn, sigmoid

torch.manual_seed(0)

# Analyze the function:
# phi_k(x, L, W) takes three parameters:
# - x: used in arithmetic operations with L and W, then passed to sigmoid
# - L: a scalar used in (x + L / 2) / W and (x - L / 2) / W
# - W: a scalar used as divisor in (x + L / 2) / W and (x - L / 2) / W

# x should be a tensor (batch of 2, feature dim of 4)
x = torch.randn(2, 4)

# L is a scalar value
L = 1.0

# W is a scalar value (positive to avoid division issues)
W = 0.5

ARGS = {
    "x": x,
    "L": L,
    "W": W,
}
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
post_process_image Ran
ran on a synthesized input
gordicaleksa/pytorch-neural-style-transfer-fast/utils/utils.py
code served (permissive licence) · get_code("80a1a8c50d8bca42")
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 (4, 5, 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 a normalized image in CHW format (C, H, W)
# The function expects values that when denormalized will be in [0, 1] range
# We create a 3-channel image (RGB) with small spatial dimensions
dump_img = np.random.randn(3, 4, 5).astype(np.float32) * 0.2 + 0.5

ARGS = {
    'dump_img': dump_img
}
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 3, dtype family int, shape (4, 5, 3) — shape (4, 5, 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
prepare_img Ran
ran on a synthesized input
gordicaleksa/pytorch-neural-style-transfer-fast/utils/utils.py
code served (permissive licence) · get_code("178628ced80043a9")
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 4, dtype family float, shape (2, 3, 5, 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
import os
from PIL import Image
from torchvision import transforms

torch.manual_seed(0)

# Create a temporary test image file
test_img_path = "/tmp/test_image.png"
os.makedirs("/tmp", exist_ok=True)

# Create a small 8x6 RGB image and save it
img_array = np.random.randint(0, 256, (8, 6, 3), dtype=np.uint8)
img_pil = Image.fromarray(img_array, mode='RGB')
img_pil.save(test_img_path)

ARGS = {
    "img_path": test_img_path,
    "target_shape": 4,
    "device": "cpu",
    "batch_size": 2,
    "should_normalize": True,
    "is_255_range": False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, cv2, numpy, torch, torchvision — 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, 3, 5, 4) — shape (2, 3, 5, 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
preprocess_image1 Ran
ran on a synthesized input
AloneGu/keras_tf_neural_img/img_util.py
code served (permissive licence) · get_code("4c10c673f13eb53b")
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 4, dtype family float, shape (1, 64, 48, 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
from keras.preprocessing import image
import tempfile
import os
from PIL import Image

# Create a temporary image file for testing
temp_dir = tempfile.mkdtemp()
image_path = os.path.join(temp_dir, "test_image.jpg")

# Create a simple test image using PIL
test_image = Image.new('RGB', (100, 100), color='red')
test_image.save(image_path)

ARGS = {
    'image_path': image_path,
    'img_nrows': 64,
    'img_ncols': 48
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, keras, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 4, dtype family float, shape (1, 64, 48, 3) — shape (1, 64, 48, 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
preprocess_input Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cryu854/FastStyle/modules/vgg19.py
code served (permissive licence) · get_code("45d5e3cf42e43b89")
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 4, dtype family float, shape (2, 4, 3, 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 a small batch of images
# The function expects a 3D or 4D array
# Using 4D: (batch_size, height, width, channels)
# Keep it tiny: batch=2, height=4, width=3, channels=3 (RGB)
x = np.random.rand(2, 4, 3, 3).astype(np.float32) * 255

ARGS = {
    'x': x
}
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 4, dtype family float, shape (2, 4, 3, 3) — shape (2, 4, 3, 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
subtract_imagenet_mean_batch Ran
ran on a synthesized input
abhiskk/fast-neural-style/neural_style/utils.py
code served (permissive licence) · get_code("0f044645dc8bfd84")
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 4, dtype family float, shape (2, 3, 4, 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
from torch.autograd import Variable

torch.manual_seed(0)

# Create a batch tensor with shape (batch_size=2, channels=3, height=4, width=4)
batch = Variable(torch.randn(2, 3, 4, 4))

ARGS = {
    "batch": batch
}
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 4, dtype family float, shape (2, 3, 4, 4) — shape (2, 3, 4, 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
tensor_load_rgbimage Ran
ran on a synthesized input
abhiskk/fast-neural-style/neural_style/utils.py
code served (permissive licence) · get_code("c977b3ac7a846dcf")
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, 64, 48) 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
import torch
from PIL import Image
import tempfile
import os

torch.manual_seed(0)

# Create a temporary RGB image file for testing
temp_dir = tempfile.mkdtemp()
temp_image_path = os.path.join(temp_dir, "test_image.png")

# Create a simple RGB image (3 channels, 64x48 pixels)
img_array = np.random.randint(0, 256, (64, 48, 3), dtype=np.uint8)
img = Image.fromarray(img_array, mode='RGB')
img.save(temp_image_path)

ARGS = {
    'filename': temp_image_path,
    'size': None,
    'scale': None
}
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 Tensor, ndim 3, dtype family float, shape (3, 64, 48) — shape (3, 64, 48) 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
upsample Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
ZyoungXu/MoSt-DSA/model/loss.py
code served (permissive licence) · get_code("23101166bb29f65e")
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 4, dtype family float, shape (2, 4, 6, 10) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# The function `upsample` takes a single parameter `x` which should be a 4D tensor
# representing an image batch: (batch_size, channels, height, width)

# Create a small test tensor
# batch_size=2, channels=4, height=3, width=5 (using distinct sizes)
x = torch.randn(2, 4, 3, 5)

ARGS = {
    'x': x
}
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 4, dtype family float, shape (2, 4, 6, 10) — shape (2, 4, 6, 10) 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
warp Ran
ran; our contract draft was wrong, not the code
ZyoungXu/MoSt-DSA/model/warplayer.py
code served (permissive licence) · get_code("662710159b487a9d")
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 4, dtype family float, shape (2, 3, 4, 5) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Create small tensors for tenInput and tenFlow
# tenInput: (batch, channels, height, width) = (2, 3, 4, 5)
# tenFlow: (batch, 2, height, width) = (2, 2, 4, 5) where 2 channels are (u, v) flow
tenInput = torch.randn(2, 3, 4, 5)
tenFlow = torch.randn(2, 2, 4, 5)

ARGS = {
    'tenInput': tenInput,
    'tenFlow': tenFlow
}
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 4, dtype family float, shape (2, 3, 4, 5) — shape (2, 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
Conv Not yet run
unverified (harvested, no recorded run)
thatbrguy/Dehaze-GAN/operations.py
code served (permissive licence) · get_code("e31f6b8517924ce3")
How it ran

no invocation recorded.

MaxPool Not yet run
unverified (harvested, no recorded run)
thatbrguy/Dehaze-GAN/operations.py
code served (permissive licence) · get_code("1a7af6d931522e01")
How it ran

no invocation recorded.

TransposeConv Not yet run
unverified (harvested, no recorded run)
thatbrguy/Dehaze-GAN/operations.py
code served (permissive licence) · get_code("4fcf2df9227d47b9")
How it ran

no invocation recorded.

add_train_args Not yet run
unverified (harvested, no recorded run)
MartinBuessemeyer/Artistic-Texture-Control/parameter_prediction_network/model_helper.py
code served (permissive licence) · get_code("af4a066c9ddad3bb")
How it ran

no invocation recorded.

conv Not yet run
unverified (harvested, no recorded run)
thatbrguy/Dehaze-GAN/legacy/utils.py
code served (permissive licence) · get_code("755cc95e92cadeb5")
How it ran

no invocation recorded.

deconv Not yet run
unverified (harvested, no recorded run)
thatbrguy/Dehaze-GAN/legacy/utils.py
code served (permissive licence) · get_code("288caa152d503142")
How it ran

no invocation recorded.

dummy_loss Not yet run
unverified (harvested, no recorded run)
AloneGu/keras_tf_neural_img/loss.py
code served (permissive licence) · get_code("c8978f6c3115ccde")
How it ran

no invocation recorded.

gram_matrix Not yet run
unverified (harvested, no recorded run)
AloneGu/keras_tf_neural_img/loss.py
code served (permissive licence) · get_code("3029f01644d4fa28")
How it ran

no invocation recorded.

normalize Not yet run
unverified (harvested, no recorded run)
anjalipemmaraju/styletransfernetwork/run_style_transfer.py
pointer only (licence: NONE) · get_code("0760176ab59586b9")
How it ran

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

perceptual_loss Not yet run
unverified (harvested, no recorded run)
ZyoungXu/MoSt-DSA/model/vgg19_losses.py
code served (permissive licence) · get_code("b882f1bdd6436f17")
How it ran

no invocation recorded.

resize_array Not yet run
unverified (harvested, no recorded run)
CYetlanezi/Proyecto-Opti/utils.py
pointer only (licence: NONE) · get_code("1f2f54d3be7d2fc4")
How it ran

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

style_loss Not yet run
unverified (harvested, no recorded run)
ZyoungXu/MoSt-DSA/model/vgg19_losses.py
code served (permissive licence) · get_code("ede22374e1b7ef80")
How it ran

no invocation recorded.

Also present in other papers' code

Of 46 samples lifted from this paper's linked repositories, 46 carry a function identity and 0 do not. Of the 46 distinct functions with an identity, 15 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 0 the same month, 14 later) and 31 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
exists 486 other papers
484 later, 2 undated · 78 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1804.04637 (2018-04)
EMBER: An Open Dataset for Training Static PE Malware Machine Learning Models
1809.11096 (2018-09)
Large Scale GAN Training for High Fidelity Natural Image Synthesis
and 483 more not named here
default 163 other papers
162 later, 1 undated · 27 only as an assembly brick
1810.00825 (2018-10)
Set Transformer: A Framework for Attention-based Permutation-Invariant Neural Networks
1907.01470 (2019-07)
Augmenting Self-attention with Persistent Memory
1907.05242 (2019-07)
Large Memory Layers with Product Keys
and 160 more not named here
conv 9 other papers
9 later · 1 only as an assembly brick
2011.06294 (2020-11)
Real-Time Intermediate Flow Estimation for Video Frame Interpolation
2303.09875 (2023-03)
A Dynamic Multi-Scale Voxel Flow Network for Video Prediction
2304.13596 (2023-04)
Video Frame Interpolation with Densely Queried Bilateral Correlation
and 6 more not named here
gram_matrix 9 other papers
1 dated earlier, 8 later
1508.06576 (2015-08)
A Neural Algorithm of Artistic Style
1607.08022 (2016-07)
Instance Normalization: The Missing Ingredient for Fast Stylization
1703.06953 (2017-03)
Multi-style Generative Network for Real-time Transfer
and 6 more not named here
downsample 4 other papers
4 later
2308.02097 (2023-08)
Multi-interactive Feature Learning and a Full-time Multi-modality Benchmark for Image Fusion and Segmentation
aaai_27987 (2024 (year only))
Optimize & Reduce: A Top-Down Approach for Image Vectorization
2406.09754 (2024-06)
LAVIB: A Large-scale Video Interpolation Benchmark
and 1 more not named here
warp 3 other papers
3 later
2011.06294 (2020-11)
Real-Time Intermediate Flow Estimation for Video Frame Interpolation
2401.08742 (2024-01)
Efficient4D: Fast Dynamic 3D Object Generation from a Single-view Video
2407.02315 (2024-07)
VFIMamba: Video Frame Interpolation with State Space Models
gauss_kernel 2 other papers
2 later
2406.09754 (2024-06)
LAVIB: A Large-scale Video Interpolation Benchmark
2407.02315 (2024-07)
VFIMamba: Video Frame Interpolation with State Space Models
phi_k 2 other papers
2 later
1904.12785 (2019-04)
Style Transfer by Relaxed Optimal Transport and Self-Similarity
aaai_27987 (2024 (year only))
Optimize & Reduce: A Top-Down Approach for Image Vectorization
upsample 2 other papers
2 later
2406.09754 (2024-06)
LAVIB: A Large-scale Video Interpolation Benchmark
2407.02315 (2024-07)
VFIMamba: Video Frame Interpolation with State Space Models
compute_pj 1 other paper
1 later
1904.12785 (2019-04)
Style Transfer by Relaxed Optimal Transport and Self-Similarity
deconv 1 other paper
1 later
2407.02315 (2024-07)
VFIMamba: Video Frame Interpolation with State Space Models
from_vgg 1 other paper
1 dated earlier
1508.06576 (2015-08)
A Neural Algorithm of Artistic Style
get_individual_syle_weight 1 other paper
1 later
1904.12785 (2019-04)
Style Transfer by Relaxed Optimal Transport and Self-Similarity
gram_matrix 1 other paper
1 later
1904.12785 (2019-04)
Style Transfer by Relaxed Optimal Transport and Self-Similarity
l1_loss_ignore_minus_one 1 other paper
1 later
1904.12785 (2019-04)
Style Transfer by Relaxed Optimal Transport and Self-Similarity

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 consider image transformation problems, where an input image is transformed into an output image. Recent methods for such problems typically train feed-forward convolutional neural networks using a \emph{per-pixel} loss between the output and ground-truth images. Parallel work has shown that high-quality images can be generated by defining and optimizing \emph{perceptual} loss functions based on high-level features extracted from pretrained networks. We combine the benefits of both approaches, and propose the use of perceptual loss functions for training feed-forward networks for image transformation tasks. We show results on image style transfer, where a feed-forward network is trained to solve the optimization problem proposed by Gatys et al in real-time. Compared to the optimization-based method, our network gives similar qualitative results but is three orders of magnitude faster. We also experiment with single-image super-resolution, where replacing a per-pixel loss with a perceptual loss gives visually pleasing results.

For agents

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

get_harvested_code_for_paper("1603.08155")
get_code_for_paper("1603.08155")
have("1603.08155")

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

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

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

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

Connect an agent — have() is free.