SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2112.01983 · 2021

CoNeRF: Controllable Neural Radiance Fields

arXiv · PDF · Open in the Atlas

Code that ran

18 of 21 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 2 violated it and 12 have no contract verdict; 2 failures of our instrument; 3 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2112.01983.json · badge: /api/ran/2112.01983.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
kacperkan/conerf canonical (classifier label)
classifier basis not recorded on the link
18 ran · 3 no recorded run
FunctionStatusWhere it lives
downsample_image Ran
ran on a synthesized input
kacperkan/conerf/conerf/image_utils.py
code served (permissive licence) · get_code("648bfd18569ad118")
How it ran

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

import cv2
import numpy as np

# Create a small valid test image with dimensions divisible by scale
# Using 8x12 image (divisible by 2 and 4)
image = np.random.randint(0, 256, size=(8, 12, 3), dtype=np.uint8)

# scale parameter - must divide evenly into image dimensions
scale = 2

# interp parameter - using default cv2.INTER_AREA
interp = cv2.INTER_AREA

ARGS = {
    "image": image,
    "scale": scale,
    "interp": interp,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (4, 6, 3) — shape (4, 6, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
dual_part Ran
ran on a synthesized input
kacperkan/conerf/conerf/dual_quaternion.py
code served (permissive licence) · get_code("edf1956cf4a5038b")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# A dual quaternion is typically represented as an 8-element vector
# [w, x, y, z, dw, dx, dy, dz] where the first 4 are the real part
# and the last 4 are the dual part.
# The function extracts elements from index 4 onwards (the dual part).

# Create a batch of dual quaternions with shape (batch_size, 8)
# where batch_size=2 for a small example
dq = torch.randn(2, 8)

ARGS = {
    "dq": dq
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
encode_metadata Ran
ran; our contract draft was wrong, not the code
kacperkan/conerf/conerf/evaluation.py
code served (permissive licence) · get_code("904f70cf03b3b211")
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 dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

class NerfModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.use_nerf_embed = True
        self.use_warp = True
        self.has_hyper_embed = True
        self.linear = nn.Linear(4, 4)
    
    def encode_nerf_embed(self, metadata, params=None):
        """Encodes nerf embeddings."""
        return torch.randn(2, 4)
    
    def encode_warp_embed(self, metadata, params=None):
        """Encodes warp embeddings."""
        return torch.randn(2, 4)
    
    def encode_hyper_embed(self, metadata, params=None):
        """Encodes hyper embeddings."""
        return torch.randn(2, 4)
    
    def apply(self, variables, metadata, method):
        """Mock apply method that calls the specified method."""
        return method(metadata, params=variables.get('params'))

model = NerfModel()

params = {
    'layer1': torch.randn(4, 3),
    'layer2': torch.randn(3, 2)
}

metadata = {
    'camera_id': torch.tensor([0, 1]),
    'time': torch.tensor([0.5, 0.7]),
    'embedding': torch.randn(2, 4)
}

ARGS = {
    'model': model,
    'params': params,
    'metadata': metadata
}
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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict 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
filter_sigma Ran
ran, violated the contract we drafted
kacperkan/conerf/conerf/models.py
code served (permissive licence) · get_code("ace52caf0f32358d")
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 ArrayImpl, ndim 2, dtype family float, shape (4, 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 jax.numpy as jnp
import numpy as np

# Create small sample data
num_points = 2
num_samples = 4

# Create points array with shape (num_samples, num_points, 3) for 3D coordinates
points = jnp.array(np.random.randn(num_samples, num_points, 3).astype(np.float32))

# Create sigma array with shape (num_samples, num_points)
sigma = jnp.array(np.random.rand(num_samples, num_points).astype(np.float32))

# Create render_opts dictionary with both filtering options
render_opts = {
    'dust_threshold': 0.3,
    'bounding_box': (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
}

ARGS = {
    'points': points,
    'sigma': sigma,
    'render_opts': render_opts
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 2, dtype family float, shape (4, 2) — shape (4, 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
fit_lr Ran
ran on a synthesized input
kacperkan/conerf/conerf/evaluation.py
code served (permissive licence) · get_code("23818b5e9eb30469")
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 ArrayImpl, ndim 1, dtype family float, shape (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 jax.numpy as jnp
import numpy as np

# Create small matrices for linear regression setup
# gt_attributes: shape (n_samples, n_features) - the design matrix X
# gt_betas: shape (n_samples,) or (n_samples, 1) - the target values y

np.random.seed(0)

# Create a small design matrix (2 samples, 4 features)
gt_attributes = jnp.array(np.random.randn(2, 4), dtype=jnp.float32)

# Create target values (2 samples,)
gt_betas = jnp.array(np.random.randn(2), dtype=jnp.float32)

ARGS = {
    "gt_attributes": gt_attributes,
    "gt_betas": gt_betas,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (4,) — shape (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
get_norm_layer Ran
ran on a synthesized input
kacperkan/conerf/conerf/modules.py
code served (permissive licence) · get_code("454ccbcc18d14a42")
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 partial. 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 functools
from flax import linen as nn

# Test different norm_type values
ARGS = {
    'norm_type': 'layer'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type partial — a partial output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a partial 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
im Ran
ran, honoured the contract we drafted
kacperkan/conerf/conerf/quaternion.py
code served (permissive licence) · get_code("213afad59d1cc5a5")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 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 im(q) expects q to be a tensor-like object that supports
# indexing with [..., :3] to extract the first 3 elements along the last dimension.
# This is consistent with quaternion representation where q has shape (..., 4)
# with the last 4 elements being [w, x, y, z] or [x, y, z, w] depending on convention.
# The imaginary part is the first 3 components.

q = torch.randn(2, 4)

ARGS = {
    "q": q
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
make_divisible Ran
ran on a synthesized input
kacperkan/conerf/conerf/image_utils.py
code served (permissive licence) · get_code("473d0abee51ef958")
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 (6, 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 sample image that is NOT divisible by the divisor
# Using shape (7, 5, 3) so height=7, width=5, channels=3
image = np.random.randint(0, 256, size=(7, 5, 3), dtype=np.uint8)

# Divisor to test with
divisor = 3

ARGS = {
    "image": image,
    "divisor": divisor
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (6, 3, 3) — shape (6, 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
matmul Ran
ran, honoured the contract we drafted
kacperkan/conerf/conerf/rigid_body.py
code served (permissive licence) · get_code("00ae174fdda5d6ee")
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 ArrayImpl, ndim 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
from jax import numpy as jnp

# Create small JAX arrays for matrix multiplication
# Using distinct dimensions: 2x4 and 4x3 to make shapes unambiguous
a = jnp.ones((2, 4), dtype=jnp.float32)
b = jnp.ones((4, 3), dtype=jnp.float32)

ARGS = {
    "a": a,
    "b": b,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
piecewise_constant_pdf Ran
ran on a synthesized input
kacperkan/conerf/conerf/model_utils.py
code served (permissive licence) · get_code("fe07bf2cca14c296")
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 ArrayImpl, ndim 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
from jax import random

# Set seed for reproducibility
key = random.PRNGKey(0)

# Define parameters for the function
batch_size = 2
n_bins = 4
num_coarse_samples = 3

# Create the key (split for fresh randomness)
key = random.split(key)[0]

# bins: [batch_size, n_bins + 1]
bins = jnp.array([
    [0.0, 0.25, 0.5, 0.75, 1.0],
    [0.0, 0.2, 0.4, 0.6, 0.8]
], dtype=jnp.float32)

# weights: [batch_size, n_bins]
weights = jnp.array([
    [1.0, 2.0, 1.5, 1.2],
    [0.8, 1.5, 2.0, 1.0]
], dtype=jnp.float32)

ARGS = {
    "key": key,
    "bins": bins,
    "weights": weights,
    "num_coarse_samples": num_coarse_samples,
    "use_stratified_sampling": True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
re Ran
ran, violated the contract we drafted
kacperkan/conerf/conerf/quaternion.py
code served (permissive licence) · get_code("99ecf48d9c0978bd")
How it ran

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

import torch

torch.manual_seed(0)

# The function extracts the real part of a quaternion from the last dimension
# q[..., 3:] means it takes all elements from index 3 onwards in the last dimension
# For a quaternion, we typically have 4 components, so this extracts the last component

# Create a quaternion tensor with shape (2, 4) - batch of 2 quaternions, 4 components each
q = torch.randn(2, 4)

ARGS = {
    "q": q
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 1) — shape (2, 1) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
real_part Ran
ran on a synthesized input
kacperkan/conerf/conerf/dual_quaternion.py
code served (permissive licence) · get_code("8226212df4de9c5e")
How it ran

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

import torch

torch.manual_seed(0)

# The function real_part(dq) expects dq to be indexable with [..., :4]
# This means it should be a tensor with at least one dimension, where the last dimension has size >= 4
# A dual quaternion typically has 8 components (4 for real part, 4 for dual part)
# We'll create a small batch of dual quaternions

dq = torch.randn(2, 8)

ARGS = {
    "dq": dq
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rp_to_se3 Ran
ran on a synthesized input
kacperkan/conerf/conerf/rigid_body.py
code served (permissive licence) · get_code("56b844c9ac825a3b")
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 ArrayImpl, 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 jax.numpy as jnp
import numpy as np

# Create a valid rotation matrix (3, 3)
# Using a simple rotation matrix around z-axis
theta = np.pi / 4
R = np.array([
    [np.cos(theta), -np.sin(theta), 0.0],
    [np.sin(theta), np.cos(theta), 0.0],
    [0.0, 0.0, 1.0]
])
R = jnp.array(R, dtype=jnp.float32)

# Create a translation vector (3,)
p = jnp.array([1.0, 2.0, 3.0], dtype=jnp.float32)

ARGS = {
    "R": R,
    "p": p
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, 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
safe_acos Ran
ran on a synthesized input
kacperkan/conerf/conerf/quaternion.py
code served (permissive licence) · get_code("8ae27734580e79f6")
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 ArrayImpl, ndim 1, dtype family float, shape (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 jax.numpy as jnp
import numpy as np

# Create a small array with values in the valid range for arccos: [-1, 1]
# Using values well within the safe range to test the function
t_value = jnp.array([0.0, 0.5, -0.5, 0.9])

ARGS = {
    "t": t_value,
    "eps": 1e-07
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (4,) — shape (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
sample_along_rays Ran
ran; our contract draft was wrong, not the code
kacperkan/conerf/conerf/model_utils.py
code served (permissive licence) · get_code("468a6904c005bfcf")
How it ran

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

import jax
import jax.numpy as jnp
from jax import random

# Set seed for reproducibility
key = random.PRNGKey(0)

# Define small test data
batch_size = 2
num_coarse_samples = 4
ray_dim = 3

# Create ray origins: [batch_size, 3]
origins = jnp.array([
    [0.0, 0.0, 0.0],
    [1.0, 1.0, 1.0]
], dtype=jnp.float32)

# Create ray directions: [batch_size, 3]
directions = jnp.array([
    [0.0, 0.0, 1.0],
    [0.1, 0.1, 0.9]
], dtype=jnp.float32)

# Near and far clipping planes
near = 0.1
far = 10.0

ARGS = {
    "key": key,
    "origins": origins,
    "directions": directions,
    "num_coarse_samples": num_coarse_samples,
    "near": near,
    "far": far,
    "use_stratified_sampling": True,
    "use_linear_disparity": False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
skew Ran
ran on a synthesized input
kacperkan/conerf/conerf/rigid_body.py
code served (permissive licence) · get_code("f4a2f8cdb9589fef")
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 ArrayImpl, 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 jax
from jax import numpy as jnp

# Create a simple 3-vector as input
w = jnp.array([1.0, 2.0, 3.0])

ARGS = {
    "w": w
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, 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
split_parts Ran
ran on a synthesized input
kacperkan/conerf/conerf/dual_quaternion.py
code served (permissive licence) · get_code("8694f14e6351b246")
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 3, 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

torch.manual_seed(0)

# A dual quaternion is represented as an 8-dimensional vector
# where the first 4 components are the real part (quaternion)
# and the last 4 components are the dual part (quaternion)
dq = torch.randn(2, 8)

ARGS = {
    "dq": dq
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 3, 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
upsample_image Ran
ran on a synthesized input
kacperkan/conerf/conerf/image_utils.py
code served (permissive licence) · get_code("3d86de8033014a47")
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 (8, 6, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import cv2
import numpy as np

# Create a small test image (4 height x 3 width x 3 channels - RGB)
image = np.random.randint(0, 256, size=(4, 3, 3), dtype=np.uint8)

# Define scale factor
scale = 2

# Define interpolation method (using default)
interp = cv2.INTER_AREA

ARGS = {
    "image": image,
    "scale": scale,
    "interp": interp,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (8, 6, 3) — shape (8, 6, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
encode_attribute Not yet run
unverified (harvested, no recorded run)
kacperkan/conerf/conerf/evaluation.py
code served (permissive licence) · get_code("d100f1f45ecdf752")
How it ran

no invocation recorded.

prepare_data Not yet run
unverified (harvested, no recorded run)
kacperkan/conerf/conerf/datasets/core.py
code served (permissive licence) · get_code("9a81b23f16137906")
How it ran

no invocation recorded.

volumetric_rendering Not yet run
unverified (harvested, no recorded run)
kacperkan/conerf/conerf/model_utils.py
code served (permissive licence) · get_code("3fd60908c59ac493")
How it ran

no invocation recorded.

Also present in other papers' code

Of 21 samples lifted from this paper's linked repositories, 21 carry a function identity and 0 do not. Of the 21 distinct functions with an identity, 10 are also present in other papers whose code we hold (4 with at least one paper dated earlier, 0 the same month, 8 later) and 11 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
matmul 5 other papers
1 dated earlier, 4 later
2103.13415 (2021-03)
Mip-NeRF: A Multiscale Representation for Anti-Aliasing Neural Radiance Fields
2211.12285 (2022-11)
Exact-NeRF: An Exploration of a Precise Volumetric Parameterization for Neural Radiance Fields
2302.08788 (2023-02)
MixNeRF: Modeling a Ray with Mixture Density for Novel View Synthesis from Sparse Inputs
and 2 more not named here
filter_sigma 2 other papers
1 dated earlier, 1 later
2106.13228 (2021-06)
HyperNeRF: A Higher-Dimensional Representation for Topologically Varying Neural Radiance Fields
2303.14435 (2023-03)
NeRF-DS: Neural Radiance Fields for Dynamic Specular Objects
dual_part 1 other paper
1 later
2303.14435 (2023-03)
NeRF-DS: Neural Radiance Fields for Dynamic Specular Objects
encode_metadata 1 other paper
1 later
2303.14435 (2023-03)
NeRF-DS: Neural Radiance Fields for Dynamic Specular Objects
get_norm_layer 1 other paper
1 later
2303.14435 (2023-03)
NeRF-DS: Neural Radiance Fields for Dynamic Specular Objects
im 1 other paper
1 dated earlier
2106.13228 (2021-06)
HyperNeRF: A Higher-Dimensional Representation for Topologically Varying Neural Radiance Fields
re 1 other paper
1 dated earlier
2106.13228 (2021-06)
HyperNeRF: A Higher-Dimensional Representation for Topologically Varying Neural Radiance Fields
real_part 1 other paper
1 later
2303.14435 (2023-03)
NeRF-DS: Neural Radiance Fields for Dynamic Specular Objects
sample_along_rays 1 other paper
1 later
2303.14435 (2023-03)
NeRF-DS: Neural Radiance Fields for Dynamic Specular Objects
split_parts 1 other paper
1 later
2303.14435 (2023-03)
NeRF-DS: Neural Radiance Fields for Dynamic Specular Objects

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

Repositories linked to this paper

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

Abstract

We extend neural 3D representations to allow for intuitive and interpretable user control beyond novel view rendering (i.e. camera control). We allow the user to annotate which part of the scene one wishes to control with just a small number of mask annotations in the training images. Our key idea is to treat the attributes as latent variables that are regressed by the neural network given the scene encoding. This leads to a few-shot learning framework, where attributes are discovered automatically by the framework, when annotations are not provided. We apply our method to various scenes with different types of controllable attributes (e.g. expression control on human faces, or state control in movement of inanimate objects). Overall, we demonstrate, to the best of our knowledge, for the first time novel view and novel attribute re-rendering of scenes from a single video.

For agents

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

get_harvested_code_for_paper("2112.01983")
get_code_for_paper("2112.01983")
have("2112.01983")

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

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

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

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

Connect an agent — have() is free.