SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1508.06576 · 2015

A Neural Algorithm of Artistic Style

arXiv · PDF · Open in the Atlas

Code that ran

76 of 110 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 8 honoured the contract we drafted, 3 violated it and 32 have no contract verdict; 33 failures of our instrument; 34 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/1508.06576.json · badge: /api/ran/1508.06576.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
Kautenja/a-neural-algorithm-of-artistic-style community (classifier label)
classifier basis not recorded on the link
5 ran · 1 no recorded run
joelsimonoff/gram-adversary-detection extension (classifier label)
classifier basis: classifier_2025
5 ran · 0 no recorded run
Shilpil/style-transfer community (classifier label)
classifier basis not recorded on the link
3 ran · 4 no recorded run
NateKoenig/https-github.com-Kautenja-a-neural-algorithm-of-artistic-style community (classifier label)
classifier basis not recorded on the link
3 ran · 4 no recorded run
mauriciomani/NST_instagram community (classifier label)
classifier basis not recorded on the link
3 ran · 1 no recorded run
dstein64/pastiche reimplementation (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
anishathalye/neural-style reimplementation (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
gordicaleksa/pytorch-neural-style-transfer community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
jtiger958/style-transfer-pytorch community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
meet-minimalist/A-Neural-Algorithm-of-Artistic-Style-Paper-Implementation reimplementation (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
takaahii/chainer-gogh reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 1 no recorded run
pfnet-research/chainer-gogh community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
sourabhsh55/Neural-Style-Transferring community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
thiagoambiel/PortraitStylization community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
SupratimH/neural-style-transfer community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
divyanshu092/Photorealistic_Style_Transfer community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
MuhamedKamil/Neural-Style-Transfer- reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
pierpaolosepe/Neural-Style-Transfer reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
parasgulati8/Neural-Style-Transfer reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
sechetbot/Gatys_torch reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
PARC/intricate-art-neural-transfer reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
ShawnWilliams/style_transfer reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
algonomicon/a-neural-algorithm-of-artistic-style community (classifier label)
classifier basis not recorded on the link
1 ran · 1 no recorded run
anhoangphuc/neural_style_transfer reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
pravitc/Neural-style-transfer-using-Pytorch reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
FunctionStatusWhere it lives
G_p Ran
ran; our contract draft was wrong, not the code
joelsimonoff/gram-adversary-detection/new-work/model-training/utils/detector.py
pointer only (licence: NONE) · get_code("17dd7052b2035130")
How it ran

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

ReadImage Ran
ran, honoured the contract we drafted
MuhamedKamil/Neural-Style-Transfer-/NeuralStyleMain.py
pointer only (licence: NONE) · get_code("cd20d71f3d46c5b7")
How it ran

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

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

import numpy as np

# The function expects x0 to be a numpy array with at least shape (1, 3, H, W)
# where the first dimension is batch-like, second is channels (at least 3 for RGB),
# and last two are spatial dimensions.

# Create a small 4D numpy array with shape (1, 3, 2, 3)
# batch=1, channels=3, height=2, width=3
x0 = np.random.randn(1, 3, 2, 3).astype(np.float32)

ARGS = {
    'x0': x0
}
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 (1, 3, 2, 3) — shape (1, 3, 2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
add_mean Ran
ran on a synthesized input
pfnet-research/chainer-gogh/chainer-gogh-multi.py
code served (permissive licence) · get_code("f722902f90ece748")
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 (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 numpy as np

# Analyze the function: it takes x0, copies it, and modifies indices [0], [1], [2]
# This suggests x0 is a 3D array-like object with at least 3 elements along first dimension
# The function accesses x[i, :, :] so it needs at least 3 dimensions
# It calls .copy() method, so x0 should be a numpy array

torch_manual_seed = 0  # placeholder, not needed for numpy

# Create a small 3D numpy array
# Shape: (3, 4, 5) - first dim has 3 elements, other dims are distinct for probing
x0 = np.random.randn(3, 4, 5).astype(np.float32)

ARGS = {
    "x0": x0
}
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 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
calc_gram_matrix Ran
ran on a synthesized input
jihoonerd/A-Neural-Algorithm-of-Artistic-Style/styletf/utils.py
code served (permissive licence) · get_code("096a683976e685f8")
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, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf
import numpy as np

# Create a small input tensor with shape [1, height, width, channel]
# Using distinct sizes: 1 for batch, 4 for height, 3 for width, 2 for channel
height = 4
width = 3
channel = 2

# Create a random input tensor
input_mat = tf.constant(
    np.random.randn(1, height, width, channel).astype(np.float32)
)

ARGS = {
    "input_mat": input_mat
}
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, 2) — shape (2, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_content_loss Ran
ran; our contract draft was wrong, not the code
pierpaolosepe/Neural-Style-Transfer/StyleTransfer.py
pointer only (licence: NONE) · get_code("0fb4817e29060f4d")
How it ran

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

content_loss Ran
ran on a synthesized input
Kautenja/a-neural-algorithm-of-artistic-style/src/loss_functions.py
code served (permissive licence) · get_code("e526a960dad796ef")
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 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 tensorflow as tf
from tensorflow.keras import backend as K
import numpy as np

# Create small tensors for content and combination
# These should have the same shape since they represent layer outputs
# Using shape (2, 4) - batch size 2, feature dimension 4
content_tensor = tf.constant(np.random.randn(2, 4).astype(np.float32))
combination_tensor = tf.constant(np.random.randn(2, 4).astype(np.float32))

ARGS = {
    "content": content_tensor,
    "combination": combination_tensor,
}
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 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
content_loss Ran
ran on a synthesized input
sourabhsh55/Neural-Style-Transferring/Neural_Styling.py
code served (permissive licence) · get_code("f6fc46e6b4a70362")
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 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 tensorflow as tf
import numpy as np

# Create small TensorFlow tensors for the image inputs
# Images are typically in shape (batch, height, width, channels)
# Using batch=2, height=4, width=3, channels=2 for distinct dimensions
base_img = tf.constant(np.random.randn(2, 4, 3, 2).astype(np.float32))
target_img = tf.constant(np.random.randn(2, 4, 3, 2).astype(np.float32))

ARGS = {
    "base_img": base_img,
    "target_img": target_img,
}
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 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
cov Ran
ran; our contract draft was wrong, not the code
dstein64/pastiche/pastiche/pastiche.py
code served (permissive licence) · get_code("89781f43f5f94876")
How it ran

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

# Create a 2D input tensor with shape (batch_size, features)
# Using 6 samples and 4 features to make dimensions distinct
input_tensor = torch.randn(6, 4)

ARGS = {
    "input": input_tensor
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (4, 4) — shape (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
cpu Ran
ran; our contract draft was wrong, not the code
joelsimonoff/gram-adversary-detection/new-work/model-training/utils/detector.py
pointer only (licence: NONE) · get_code("48a9e0f0fbcaf665")
How it ran

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

denormalize Ran
ran on a synthesized input
Kautenja/a-neural-algorithm-of-artistic-style/src/normalize.py
code served (permissive licence) · get_code("51810239167bbb4c")
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 (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 BGR image (height=4, width=3, channels=3)
# Initialize with values that are clearly distinguishable after denormalization
image = np.random.randn(4, 3, 3).astype(np.float32) * 10

ARGS = {
    "image": image,
    "inplace": False,
}
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 float, shape (4, 3, 3) — shape (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
deprocess_image Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RyanWu2233/Style_Transfer/Gatys_Style_Transfer.py
pointer only (licence: NONE) · get_code("f5824548bce0cf77")
How it ran

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

deprocess_image Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Anna996/Neural-Style-Transfer-Project/project.py
pointer only (licence: NONE) · get_code("20622f082cf94c34")
How it ran

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

deprocess_image Ran
ran on a synthesized input
Shilpil/style-transfer/load_process_img.py
code served (permissive licence) · get_code("23013fe9f6818d01")
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 (2, 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 numpy as np
import torch

torch.manual_seed(0)

# The function deprocess_image takes an image array and:
# 1. Adds VGG_MEAN to it
# 2. Clips values to [0, 255]
# 3. Converts to uint8
# 
# The parameter 'img' should be a numpy array with shape compatible for broadcasting
# with VGG_MEAN (which has shape (3,))
# Typical image shapes are (H, W, 3) or (C, H, W) or (B, C, H, W)

# Create a small test image array with shape (2, 4, 3) - batch of 2, 4x4 images, 3 channels
# Use values that when VGG_MEAN is added, will be in a reasonable range
img = np.random.randn(2, 4, 3).astype(np.float32) * 50 + 50

ARGS = {
    "img": img
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (2, 4, 3) — shape (2, 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
deprocess_img Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
arnavdodiedo/Neural-Style-Transfer/style-transfer-tf.py
pointer only (licence: NONE) · get_code("14acab4ee579054f")
How it ran

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

deprocess_img Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
MuhamedKamil/Neural-Style-Transfer-/NeuralStyleMain.py
pointer only (licence: NONE) · get_code("0705bbb11a13554c")
How it ran

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

fmt_imsave Ran
ran; our contract draft was wrong, not the code
anishathalye/neural-style/neural_style.py
pointer only (licence: GPL-3.0) · get_code("250050d60eb97067")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, anishathalye/neural-style, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

from_vgg Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
aryan-mann/style-transfer/image_transformation.py
pointer only (licence: GPL-3.0) · get_code("79bc8cd94a78aa43")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, aryan-mann/style-transfer, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

gen_scales Ran
ran on a synthesized input
thiagoambiel/PortraitStylization/utils/modules.py
code served (permissive licence) · get_code("43e24050e201054c")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Analyzing the function gen_scales:
# - Takes start: int (lower bound for scale)
# - Takes end: int (upper bound for scale)
# - Returns List[Any] (sorted list of scales)
# The function generates scales by repeatedly dividing end by powers of 2^(i/2)
# until the result is <= start

ARGS = {
    "start": 10,
    "end": 100,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family int — 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
generate_noise_image Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
parasgulati8/Neural-Style-Transfer/nst_utils.py
code served (permissive licence) · get_code("7db674bb1d9e27f9")
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 (1, 300, 400, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

class CONFIG:
    IMAGE_WIDTH = 400
    IMAGE_HEIGHT = 300
    COLOR_CHANNELS = 3
    NOISE_RATIO = 0.6
    MEANS = np.array([123.68, 116.779, 103.939]).reshape((1, 1, 1, 3))
    VGG_MODEL = 'pretrained-model/imagenet-vgg-verydeep-19.mat'
    STYLE_IMAGE = 'images/stone_style.jpg'
    CONTENT_IMAGE = 'images/content300.jpg'
    OUTPUT_DIR = 'output/'

content_image = np.random.randn(1, CONFIG.IMAGE_HEIGHT, CONFIG.IMAGE_WIDTH, CONFIG.COLOR_CHANNELS).astype('float32')

ARGS = {
    'content_image': content_image,
    'noise_ratio': CONFIG.NOISE_RATIO
}
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 (1, 300, 400, 3) — shape (1, 300, 400, 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
generate_noise_image Ran
ran; our contract draft was wrong, not the code
ShawnWilliams/style_transfer/utils.py
pointer only (licence: NONE) · get_code("60023b504b02d356")
How it ran

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

generate_noise_image Ran
ran on a synthesized input
SupratimH/neural-style-transfer/nst_utils.py
code served (permissive licence) · get_code("63c8651f4af5dd84")
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, 600, 400, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

class CONFIG:
    IMAGE_WIDTH = 400
    IMAGE_HEIGHT = 600
    COLOR_CHANNELS = 3
    NOISE_RATIO = 0.6
    MEANS = np.array([123.68, 116.779, 103.939]).reshape((1, 1, 1, 3))
    VGG_MODEL = 'pretrained-model/imagenet-vgg-verydeep-19.mat'
    STYLE_IMAGE = 'images/stone_style.jpg'
    CONTENT_IMAGE = 'images/content300.jpg'
    OUTPUT_DIR = 'output/'

# Create a content image with shape (1, IMAGE_HEIGHT, IMAGE_WIDTH, COLOR_CHANNELS)
content_image = np.random.randn(1, CONFIG.IMAGE_HEIGHT, CONFIG.IMAGE_WIDTH, CONFIG.COLOR_CHANNELS).astype('float32')

ARGS = {
    'content_image': content_image,
    'noise_ratio': CONFIG.NOISE_RATIO
}
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 4, dtype family float, shape (1, 600, 400, 3) — shape (1, 600, 400, 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
generate_out_img_name Ran
ran on a synthesized input
gordicaleksa/pytorch-neural-style-transfer/utils/utils.py
code served (permissive licence) · get_code("4a37684ac7e3523f")
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

config = {
    'content_img_name': '/path/to/content_image.jpg',
    'style_img_name': '/path/to/style_image.png',
    'optimizer': 'adam',
    'height': '512',
    'model': 'vgg19',
    'img_format': '.jpg',
    'init_method': 'random',
    'content_weight': 1.0,
    'style_weight': 100.0,
    'tv_weight': 0.001
}

ARGS = {
    'config': config
}
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
get_loader Ran
ran on a synthesized input
jtiger958/style-transfer-pytorch/dataloader/dataloader.py
code served (permissive licence) · get_code("bb819e37f3028e3b")
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.utils.data
import os
import tempfile
from PIL import Image
import numpy as np

torch.manual_seed(0)

# Create a temporary directory with test images
temp_dir = tempfile.mkdtemp()

# Create a few small test images
for i in range(5):
    img_array = np.random.randint(0, 256, (64, 64, 3), dtype=np.uint8)
    img = Image.fromarray(img_array, 'RGB')
    img.save(os.path.join(temp_dir, f'test_image_{i}.png'))

ARGS = {
    'data_dir': temp_dir,
    'image_size': 32,
    'batch_size': 2,
    'sample_batch_size': 2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy, torch, torchvision — 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
get_model_and_losses Ran
ran; our contract draft was wrong, not the code
sechetbot/Gatys_torch/Gatys_torch.py
pointer only (licence: NONE) · get_code("7f30b7c1360c80a7")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, sechetbot/Gatys_torch 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 Ran
ran; our contract draft was wrong, not the code
sechetbot/Gatys_torch/Gatys_torch.py
pointer only (licence: NONE) · get_code("a900a01e9cafb797")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, sechetbot/Gatys_torch 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 Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
dstein64/pastiche/pastiche/pastiche.py
code served (permissive licence) · get_code("b1bc0ec833177297")
How it ran

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

torch.manual_seed(0)

# The function expects input with shape (batch, channels, height, width)
# It squeezes dimension 0, so batch should be 1
# Then flattens spatial dimensions and computes gram matrix
# Using distinct dimensions: batch=1, channels=3, height=4, width=5

input_tensor = torch.randn(1, 3, 4, 5)

ARGS = {
    'input': input_tensor
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (3, 3) — shape (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
gram_matrix Ran
ran; our contract draft was wrong, not the code
algonomicon/a-neural-algorithm-of-artistic-style/src/model.py
pointer only (licence: MIT); the stored copy get_code serves, from Oldpan/Deep-Painterly-Harmonization-Pytorch, is pointer only (licence: NONE) · get_code("1090950b58e9358b")
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 Oldpan/Deep-Painterly-Harmonization-Pytorch, 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; our contract draft was wrong, not the code
safwankdb/Neural-Style-Transfer/styletransfer.py
pointer only (licence: NONE) · get_code("937f431a534924fe")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, safwankdb/Neural-Style-Transfer 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
pierpaolosepe/Neural-Style-Transfer/StyleTransfer.py
pointer only (licence: NONE) · get_code("7998acea93b36090")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, pierpaolosepe/Neural-Style-Transfer 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
jtiger958/style-transfer-pytorch/utils/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; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mauriciomani/NST_instagram/neural_style_transfer.py
code served (permissive licence) · get_code("d52a32dc6bd4f8a5")
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 3, dtype family float, shape (2, 5, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf
import numpy as np

# Create a small input tensor for the gram_matrix function
# The function expects input_tensor with shape (batch, height, width, channels)
# Using batch=2, height=3, width=4, channels=5 for distinct dimensions
batch_size = 2
height = 3
width = 4
channels = 5

# Create a random input tensor
input_tensor = tf.random.normal((batch_size, height, width, channels), dtype=tf.float32)

ARGS = {
    'input_tensor': input_tensor
}
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 3, dtype family float, shape (2, 5, 5) — shape (2, 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
hex_to_rgb Ran
ran, honoured the contract we drafted
PARC/intricate-art-neural-transfer/intricate_style.py
pointer only (licence: NONE) · get_code("0a5283ca98594d70")
How it ran

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

im_convert Ran
ran; our contract draft was wrong, not the code
anhoangphuc/neural_style_transfer/style_transfer_script.py
pointer only (licence: NONE) · get_code("7896e0747ff986bc")
How it ran

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

im_convert Ran
ran; our contract draft was wrong, not the code
itzpankajpanwar/iMagine/style_transfer.py
code served (permissive licence) · get_code("1e8bc3f41f3ac089")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# The function expects a tensor in shape (C, H, W) format (channels first)
# It will squeeze, transpose to (H, W, C), denormalize with ImageNet stats, and clip
# We need at least 3 channels for the denormalization to work properly
# Let's create a small 3-channel image tensor

# Create a tensor with shape (3, 5, 7) - 3 channels, height 5, width 7
# The tensor should be normalized (as if it came from a normalized dataset)
tensor = torch.randn(3, 5, 7)

ARGS = {
    'tensor': tensor
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family float, shape (5, 7, 3) — shape (5, 7, 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
im_convert Ran
ran on a synthesized input
divyanshu092/Photorealistic_Style_Transfer/Code/utils.py
code served (permissive licence) · get_code("03cf789639831558")
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 (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 torch
import numpy as np

torch.manual_seed(0)

# The function expects a tensor with shape (batch, channel, height, width)
# After squeeze(0) it becomes (channel, height, width)
# So we need to create a tensor with batch=1, channel=3, height=4, width=5
tensor = torch.rand(1, 3, 4, 5)

ARGS = {
    "tensor": tensor
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family float, 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
image_convert Ran
ran; our contract draft was wrong, not the code
pravitc/Neural-style-transfer-using-Pytorch/style_transfer.py
pointer only (licence: NONE) · get_code("10c26199e767747a")
How it ran

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

image_read Ran
ran on a synthesized input
mauriciomani/NST_instagram/neural_style_transfer.py
code served (permissive licence) · get_code("c01f9d98302f7539")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned EagerTensor, ndim 4, dtype family float, shape (1, 720, 540, 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 tensorflow as tf
import tempfile
import numpy as np

# Create a temporary image file for testing
with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
    # Create a simple RGB image (4x3 pixels for distinctness)
    img_array = np.random.randint(0, 256, (4, 3, 3), dtype=np.uint8)
    
    # Encode as PNG
    img_tensor = tf.convert_to_tensor(img_array)
    encoded = tf.io.encode_png(img_tensor)
    
    # Write to temp file
    with open(tmp.name, 'wb') as f:
        f.write(encoded.numpy())
    
    image_path = tmp.name

ARGS = {
    'image_path': image_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 4, dtype family float, shape (1, 720, 540, 3) — shape (1, 720, 540, 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
image_to_matrix Ran
ran on a synthesized input
NateKoenig/https-github.com-Kautenja-a-neural-algorithm-of-artistic-style/neural_stylization/util/img_util.py
code served (permissive licence) · get_code("7cf9b4ab2b6aa491")
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, 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.

from PIL import Image
import numpy as np

# Create a small test image
# Using RGB mode with a 4x3 pixel image for distinct dimensions
image_array = np.random.randint(0, 256, (4, 3, 3), dtype=np.uint8)
test_image = Image.fromarray(image_array, mode='RGB')

ARGS = {
    "image": test_image,
    "dtype": np.float32,
}
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 ndarray, ndim 4, dtype family float, shape (1, 4, 3, 3) — shape (1, 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
images_extraction Ran
ran on a synthesized input
mauriciomani/NST_instagram/google_api.py
code served (permissive licence) · get_code("27eeb0e881917f01")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 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 random
from unittest.mock import Mock, MagicMock

# Create a mock Google Drive API service
mock_service = Mock()

# Create mock file objects that would be returned by the API
mock_files = [
    {'id': 'file_id_1', 'name': 'image1.jpg'},
    {'id': 'file_id_2', 'name': 'image2.png'},
    {'id': 'file_id_3', 'name': 'image3.jpg'},
]

# Configure the mock to return the files
mock_files_list = mock_service.files().list(
    q="'test_folder_id' in parents",
    spaces='drive',
    fields='nextPageToken, files(id, name)',
    pageToken=None
)
mock_files_list.execute.return_value = {
    'files': mock_files,
    'nextPageToken': None
}

# Set up the service to return our mock
mock_service.files.return_value.list.return_value.execute.return_value = {
    'files': mock_files,
    'nextPageToken': None
}

# Seed random for reproducibility
random.seed(42)

ARGS = {
    'service': mock_service,
    'id_folder': 'test_folder_id',
    'list_files': False
}
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 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
imread Ran
ran, honoured the contract we drafted
anishathalye/neural-style/neural_style.py
pointer only (licence: GPL-3.0) · get_code("3ba270f43555366d")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, anishathalye/neural-style, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

imresize Ran
ran; our contract draft was wrong, not the code
anishathalye/neural-style/neural_style.py
pointer only (licence: GPL-3.0) · get_code("119c4329189eec69")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, anishathalye/neural-style, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

load_image Ran
ran, honoured the contract we drafted
dstein64/pastiche/pastiche/pastiche.py
code served (permissive licence) · get_code("b6dd9b05db159537")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned Tensor, ndim 4, dtype family float, shape (1, 3, 6, 8) 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
from PIL import Image
import torch
import tempfile
import os

# Create a small test image file
torch.manual_seed(0)

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

# Create a small RGB image (10x8 pixels)
img = Image.new('RGB', (10, 8), color=(100, 150, 200))
img.save(image_path)

ARGS = {
    "image_path": image_path,
    "pixels": 50,
    "size": None
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
PIL, 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 (1, 3, 6, 8) — shape (1, 3, 6, 8) 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
NateKoenig/https-github.com-Kautenja-a-neural-algorithm-of-artistic-style/neural_stylization/util/img_util.py
code served (permissive licence) · get_code("d94e5a160f0488b5")
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 tempfile
import os
from PIL import Image

# Create a temporary image file to use as input
temp_dir = tempfile.mkdtemp()
temp_image_path = os.path.join(temp_dir, "test_image.png")

# Create a simple test image
test_image = Image.new("RGB", (100, 80), color="red")
test_image.save(temp_image_path)

# Define arguments for the load_image function
ARGS = {
    "image_path": temp_image_path,
    "size": (50, 40)
}
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 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
load_image Ran
ran on a synthesized input
Shilpil/style-transfer/load_process_img.py
code served (permissive licence) · get_code("40059d7d76951964")
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 (10, 10, 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 tempfile
import numpy as np
import imageio

# Create a temporary image file for testing
with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
    # Create a small test image (10x10 RGB)
    test_img = np.random.randint(0, 256, (10, 10, 3), dtype=np.uint8)
    imageio.imwrite(tmp.name, test_img)
    temp_filename = tmp.name

ARGS = {
    'filename': temp_filename,
    'size': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
imageio, numpy, skimage — 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 (10, 10, 3) — shape (10, 10, 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, honoured the contract we drafted
divyanshu092/Photorealistic_Style_Transfer/Code/utils.py
code served (permissive licence) · get_code("77be836993cd1ffa")
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 (1, 3, 8, 8) 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 tempfile
from PIL import Image
import os

# Create a temporary image file for testing
torch.manual_seed(0)

# Create a small test image (4x3 pixels, RGB)
test_image = Image.new('RGB', (4, 3), color=(73, 109, 137))

# Write to temporary file
with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
    tmp_path = tmp.name
    test_image.save(tmp_path)

ARGS = {
    'img_path': tmp_path,
    'img_size': 8
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, 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 (1, 3, 8, 8) — shape (1, 3, 8, 8) 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/utils/utils.py
code served (permissive licence) · get_code("4b0bcb02119abab6")
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 (80, 100, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import cv2 as cv
import numpy as np
import os
import tempfile

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

# Create a simple test image (100x80 RGB image)
test_img = np.random.randint(0, 256, (80, 100, 3), dtype=np.uint8)
cv.imwrite(temp_img_path, test_img)

ARGS = {
    "img_path": temp_img_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 (80, 100, 3) — shape (80, 100, 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
itzpankajpanwar/Style-Transfer/style_transfer.py
code served (permissive licence) · get_code("7e2780993f07583d")
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 (1, 3, 120, 144) 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
from PIL import Image
import tempfile
import os

# Create a temporary test image
torch.manual_seed(0)

# Create a small RGB image and save it
img_array = np.random.randint(0, 256, (100, 120, 3), dtype=np.uint8)
test_image = Image.fromarray(img_array, mode='RGB')

# Save to temporary file
temp_dir = tempfile.gettempdir()
img_path = os.path.join(temp_dir, 'test_image.png')
test_image.save(img_path)

ARGS = {
    'img_path': img_path,
    'max_size': 400,
    'shape': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, 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 (1, 3, 120, 144) — shape (1, 3, 120, 144) 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
jtiger958/style-transfer-pytorch/utils/utils.py
code served (permissive licence) · get_code("ff55f83b36e933d4")
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 PIL.Image
import io
from PIL import Image as PILImage

# Create a small test image in memory
img = PILImage.new('RGB', (100, 100), color='red')
img_bytes = io.BytesIO()
img.save(img_bytes, format='PNG')
img_bytes.seek(0)

# Create a temporary file-like object that PIL can work with
class FakeFile:
    def __init__(self, pil_image):
        self.pil_image = pil_image
    
    def __enter__(self):
        return self.pil_image
    
    def __exit__(self, *args):
        pass

# Monkey patch PIL.Image.open to return our test image
original_open = PIL.Image.open
def mock_open(filename):
    return PILImage.new('RGB', (100, 100), color='blue')

PIL.Image.open = mock_open

ARGS = {
    'file_name': 'dummy_image.png',
    'size': 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 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
load_image Ran
ran on a synthesized input
yaswanthpalaghat/Implementing-Neural-Style-Transfer/nst.py
code served (permissive licence) · get_code("3cd5ad1d9a08c788")
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 (1, 3, 100, 100) 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
from PIL import Image
import tempfile
import os

torch.manual_seed(0)

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

# Create a simple RGB image and save it
img_array = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)
pil_image = Image.fromarray(img_array, 'RGB')
pil_image.save(temp_image_path)

ARGS = {
    'img_path': temp_image_path,
    'max_size': 400,
    'shape': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, 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 (1, 3, 100, 100) — shape (1, 3, 100, 100) 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_img Ran
ran on a synthesized input
sourabhsh55/Neural-Style-Transferring/Neural_Styling.py
code served (permissive licence) · get_code("31cb847b0a8e6a04")
How it ran

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

# Create a small test image: shape (4, 3, 3) for height, width, channels
img_array = np.random.rand(4, 3, 3).astype('float32') * 255

ARGS = {
    'img': img_array
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 4, dtype family float, shape (1, 4, 3, 3) — shape (1, 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
matrix_to_image Ran
ran on a synthesized input
NateKoenig/https-github.com-Kautenja-a-neural-algorithm-of-artistic-style/neural_stylization/util/img_util.py
code served (permissive licence) · get_code("edb01493d3957aa8")
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 numpy as np
from PIL import Image

# Create a small image matrix with shape [height, width, channels]
# Using distinct dimensions: 4 height, 3 width, 3 channels (RGB)
image_matrix = np.array([
    [[100, 150, 200], [50, 75, 125], [200, 225, 250]],
    [[10, 20, 30], [40, 60, 80], [120, 140, 160]],
    [[255, 200, 100], [150, 100, 50], [75, 125, 175]],
    [[30, 60, 90], [110, 130, 150], [180, 200, 220]]
], dtype=np.float32)

ARGS = {
    "image": image_matrix,
    "channel_range": (0, 255)
}
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
noise_pyramid Ran
ran; our contract draft was wrong, not the code
ProofByConstruction/texture-networks/texture_network.py
pointer only (licence: NONE) · get_code("94e70e4ca84a76c2")
How it ran

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

normalization Ran
ran on a synthesized input
Tiannia/intro_to_ai/Neural-Style-Transfer/utils.py
code served (permissive licence) · get_code("e2461546bb04850e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned EagerTensor, ndim 4, dtype family float, shape (2, 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 tensorflow as tf
import numpy as np

# Create a small test image tensor
# Shape: (2, 4, 4, 3) - batch of 2, 4x4 image, 3 channels (RGB)
# Values in range [0, 1] as typical for normalized images
x = tf.constant(np.random.rand(2, 4, 4, 3).astype(np.float32))

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 4, dtype family float, shape (2, 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
normalize Ran
ran on a synthesized input
Kautenja/a-neural-algorithm-of-artistic-style/src/normalize.py
code served (permissive licence) · get_code("bb596ffd8cd0588f")
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, 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 small test image with shape [1, H, W, 3]
# The function expects channels=3 (RGB) as per IMAGENET_MEANS shape
image = np.random.rand(1, 4, 5, 3).astype(np.float32) * 255

ARGS = {
    "image": image,
    "inplace": False,
}
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 4, dtype family float, shape (1, 4, 5, 3) — shape (1, 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
normalize_l2 Ran
ran; our contract draft was wrong, not the code
joelsimonoff/gram-adversary-detection/new-work/model-training/utils/attacks.py
pointer only (licence: NONE) · get_code("b16e920816efe253")
How it ran

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

pairs Ran
ran on a synthesized input
Kautenja/a-neural-algorithm-of-artistic-style/frames_to_video.py
code served (permissive licence) · get_code("4a448b2fb231a7f2")
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 zip. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from itertools import tee

torch.manual_seed(0)

# The function 'pairs' takes an iterable and returns sequential pairs
# It uses: tee() to create independent iterators, next() to advance one, and zip() to pair them
# The iterable can be any sequence-like object

# Create a simple iterable - a list of integers
iterable = [1, 2, 3, 4, 5]

ARGS = {
    "iterable": iterable
}
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 zip — a zip output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a zip 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
post_process_and_display Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
meet-minimalist/A-Neural-Algorithm-of-Artistic-Style-Paper-Implementation/helper.py
pointer only (licence: NONE) · get_code("d743cdda3ec02bff")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, meet-minimalist/A-Neural-Algorithm-of-Artistic-Style-Paper-Implementation 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.

postprocess Ran
ran, honoured the contract we drafted
shizuo-kaji/StyleTransfer/train_gogh.py
code served (permissive licence) · get_code("6d4c33c57b4f7f69")
How it ran

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

class StandinVar:
    def __init__(self, array, gpu):
        self.array = array
        self.gpu = gpu
        if gpu >= 0:
            # Simulate a GPU array with a .get() method
            self.array = StandinGPUArray(array)
    
class StandinGPUArray:
    def __init__(self, array):
        self._array = array
    
    def get(self):
        return self._array

# Create a small image-like array
# Shape should be (batch, channels, height, width) before transpose
# After transpose it becomes (batch, height, width, channels)
# We'll use batch=1, channels=3, height=4, width=5
img_array = np.random.randn(1, 3, 4, 5).astype(np.float32) * 10

# Test with GPU >= 0 case
var = StandinVar(img_array, gpu=1)
gpu = 1

ARGS = {
    'var': var,
    'gpu': gpu
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family 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/utils/utils.py
code served (permissive licence) · get_code("b1a4fea2b0c5d73d")
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 (1, 3, 64, 51) 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 tempfile
import os
from PIL import Image

torch.manual_seed(0)

# Create a temporary image file for testing
temp_dir = tempfile.mkdtemp()
img_array = np.random.randint(0, 256, (100, 80, 3), dtype=np.uint8)
img_pil = Image.fromarray(img_array)
temp_img_path = os.path.join(temp_dir, "test_image.jpg")
img_pil.save(temp_img_path)

ARGS = {
    "img_path": temp_img_path,
    "target_shape": 64,
    "device": torch.device("cpu")
}
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 (1, 3, 64, 51) — shape (1, 3, 64, 51) 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

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("1508.06576").

Also present in other papers' code

Of 110 samples lifted from this paper's linked repositories, 110 carry a function identity and 0 do not. Of the 101 distinct functions with an identity, 21 are also present in other papers whose code we hold (1 with at least one paper dated earlier, 0 the same month, 21 later) and 80 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
gram_matrix 12 other papers
12 later
1703.07511 (2017-03)
Deep Photo Style Transfer
1804.03189 (2018-04)
Deep Painterly Harmonization
1804.07723 (2018-04)
Image Inpainting for Irregular Holes Using Partial Convolutions
and 9 more not named here
gram_matrix 9 other papers
9 later
1603.08155 (2016-03)
Perceptual Losses for Real-Time Style Transfer and Super-Resolution
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
tensor_clamp 4 other papers
4 later
1901.09960 (2019-01)
Using Pre-Training Can Improve Model Robustness and Uncertainty
1906.12340 (2019-06)
Using Self-Supervised Learning Can Improve Model Robustness and Uncertainty
1908.08016 (2019-08)
Testing Robustness Against Unforeseen Adversaries
and 1 more not named here
normalize_l2 3 other papers
3 later
1901.09960 (2019-01)
Using Pre-Training Can Improve Model Robustness and Uncertainty
1906.12340 (2019-06)
Using Self-Supervised Learning Can Improve Model Robustness and Uncertainty
1912.12510 (2019-12)
Detecting Out-of-Distribution Examples with In-distribution Examples and Gram Matrices
tensor_clamp_l2 3 other papers
3 later
1901.09960 (2019-01)
Using Pre-Training Can Improve Model Robustness and Uncertainty
1906.12340 (2019-06)
Using Self-Supervised Learning Can Improve Model Robustness and Uncertainty
1912.12510 (2019-12)
Detecting Out-of-Distribution Examples with In-distribution Examples and Gram Matrices
gram_matrix 2 other papers
2 later
1905.00561 (2019-05)
Large-scale weakly-supervised pre-training for video action recognition
2108.07379 (2021-08)
DRB-GAN: A Dynamic ResBlock Generative Adversarial Network for Artistic Style Transfer
load_image 2 other papers
2 later
2112.00374 (2021-12)
CLIPstyler: Image Style Transfer with a Single Text Condition
obj_fun 2 other papers
1 dated earlier, 1 later
1412.0035 (2014-12)
Understanding Deep Image Representations by Inverting Them
1602.02644 (2016-02)
Generating Images with Perceptual Similarity Metrics based on Deep Networks
vgg_layers 2 other papers
2 later
1905.00561 (2019-05)
Large-scale weakly-supervised pre-training for video action recognition
2108.07379 (2021-08)
DRB-GAN: A Dynamic ResBlock Generative Adversarial Network for Artistic Style Transfer
G_p 1 other paper
1 later
1912.12510 (2019-12)
Detecting Out-of-Distribution Examples with In-distribution Examples and Gram Matrices
cov 1 other paper
1 later
1611.07865 (2016-11)
Controlling Perceptual Factors in Neural Style Transfer
cpu 1 other paper
1 later
1912.12510 (2019-12)
Detecting Out-of-Distribution Examples with In-distribution Examples and Gram Matrices
from_vgg 1 other paper
1 later
1603.08155 (2016-03)
Perceptual Losses for Real-Time Style Transfer and Super-Resolution
get_random_sample 1 other paper
1 later
1703.10593 (2017-03)
Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks
gram 1 other paper
1 later
1611.07865 (2016-11)
Controlling Perceptual Factors in Neural Style Transfer
im_convert 1 other paper
1 later
2104.05623 (2021-04)
Rethinking and Improving the Robustness of Image Style Transfer
imread 1 other paper
1 later
1703.07511 (2017-03)
Deep Photo Style Transfer
load_image 1 other paper
1 later
1611.07865 (2016-11)
Controlling Perceptual Factors in Neural Style Transfer
noise_pyramid 1 other paper
1 later
1603.03417 (2016-03)
Texture Networks: Feed-forward Synthesis of Textures and Stylized Images
setup_optimizer 1 other paper
1 later
1611.07865 (2016-11)
Controlling Perceptual Factors in Neural Style Transfer

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

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

Repositories linked to this paper

More are linked than shown here.

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

Abstract

In fine art, especially painting, humans have mastered the skill to create unique visual experiences through composing a complex interplay between the content and style of an image. Thus far the algorithmic basis of this process is unknown and there exists no artificial system with similar capabilities. However, in other key areas of visual perception such as object and face recognition near-human performance was recently demonstrated by a class of biologically inspired vision models called Deep Neural Networks. Here we introduce an artificial system based on a Deep Neural Network that creates artistic images of high perceptual quality. The system uses neural representations to separate and recombine content and style of arbitrary images, providing a neural algorithm for the creation of artistic images. Moreover, in light of the striking similarities between performance-optimised artificial neural networks and biological vision, our work offers a path forward to an algorithmic understanding of how humans create and perceive artistic imagery.

For agents

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

get_harvested_code_for_paper("1508.06576")
get_code_for_paper("1508.06576")
have("1508.06576")

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

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

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

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

Connect an agent — have() is free.