SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2306.02018 · 2023

VideoComposer: Compositional Video Synthesis with Motion Controllability

arXiv · PDF · Open in the Atlas

Code that ran

16 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 7 have no contract verdict; 5 failures of our instrument; 5 no recorded run); 1 of them was also run on the host, not in the jail, by the peer-agreement lane that set its level, 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/2306.02018.json · badge: /api/ran/2306.02018.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
ali-vilab/videocomposer canonical (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
damo-vilab/videocomposer community (classifier label)
classifier basis not recorded on the link
14 ran · 5 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
FunctionStatusWhere it lives
interpolate_fn Ran
ran; our contract draft was wrong, not the code
damo-vilab/videocomposer/artist/ops/dpm_solver.py
code served (permissive licence) · get_code("6a35b62fbc80f70a")
How it ran

Ran in Syntology's jail on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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. The comparison behind this sample's level is a different run: the peer-agreement lane ran it again on the host, not in the jail (report dated 2026-09-05T00:15:28Z). 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)

# x: PyTorch tensor with shape [N, C], where N is batch size, C is number of channels
x = torch.randn(2, 1)

# xp: PyTorch tensor with shape [C, K], where K is number of keypoints
xp = torch.linspace(0, 1, 4).unsqueeze(0).repeat(1, 1)  # shape [1, 4]

# yp: PyTorch tensor with shape [C, K]
yp = torch.linspace(0, 2, 4).unsqueeze(0).repeat(1, 1)  # shape [1, 4]

ARGS = {
    "x": x,
    "xp": xp,
    "yp": yp,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 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
Normalize Ran
ran; our contract draft was wrong, not the code
ali-vilab/videocomposer/tools/videocomposer/autoencoder.py
code served (permissive licence) · get_code("9fcdaa6e423e8aa7")
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 GroupNorm. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The Normalize function takes in_channels and num_groups (with default 32)
# It returns a GroupNorm layer

# in_channels: number of channels for the GroupNorm layer
# num_groups: number of groups to separate the channels into (default 32)

# We need to provide valid arguments where num_groups divides in_channels evenly
# Let's use in_channels=64 so it's divisible by the default num_groups=32

ARGS = {
    'in_channels': 64,
    'num_groups': 32
}
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 GroupNorm — a GroupNorm output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a GroupNorm 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
beta_schedule Ran
ran on a synthesized input
damo-vilab/videocomposer/artist/ops/diffusion.py
code served (permissive licence) · get_code("6310b674ca6c549f")
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 1, dtype family float, shape (1000,) 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 math

torch.manual_seed(0)

ARGS = {
    'schedule': 'linear',
    'num_timesteps': 1000,
    'init_beta': None,
    'last_beta': None,
}
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 1, dtype family float, shape (1000,) — shape (1000,) 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
discretized_gaussian_log_likelihood Ran
ran on a synthesized input
damo-vilab/videocomposer/artist/ops/losses.py
code served (permissive licence) · get_code("c0132499fc4c9979")
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 math

torch.manual_seed(0)

# Create small tensors with distinct shapes for each parameter
# Batch size 2, feature dimension 4
batch_size = 2
feature_dim = 4

x0 = torch.randn(batch_size, feature_dim)
mean = torch.randn(batch_size, feature_dim)
log_scale = torch.randn(batch_size, feature_dim)

ARGS = {
    "x0": x0,
    "mean": mean,
    "log_scale": log_scale,
}
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
get_logger Ran
ran; our contract draft was wrong, not the code
damo-vilab/videocomposer/utils/logging.py
code served (permissive licence) · get_code("b6d6bcb982b768cc")
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 Logger. 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 logging

ARGS = {
    "name": "test_logger"
}
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 Logger — a Logger output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Logger 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_rank Ran
ran, honoured the contract we drafted
damo-vilab/videocomposer/artist/ops/distributed.py
code served (permissive licence) · get_code("1d504697143a06b9")
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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.distributed as dist

torch.manual_seed(0)

# The get_rank function takes an optional 'group' parameter
# which is used by dist.get_rank(group) if distributed is initialized
# Otherwise it returns 0 regardless of the group parameter

# Create a valid ProcessGroup object (or None, which is valid)
# Since we're not actually initializing distributed training,
# we can pass None or a mock group object
group = None

ARGS = {
    "group": group
}
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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_world_size Ran
ran, honoured the contract we drafted
damo-vilab/videocomposer/artist/ops/distributed.py
code served (permissive licence) · get_code("151fc386a67a4f69")
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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.distributed as dist
from unittest.mock import MagicMock, patch

torch.manual_seed(0)

# The function get_world_size takes an optional 'group' parameter
# which is passed to dist.get_world_size(group) if distributed is initialized.
# Since we're not actually initializing distributed training, we just need
# to provide a valid value for the group parameter.

# Create a mock process group (or None, which is the default)
mock_group = None

ARGS = {
    "group": mock_group
}
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 int, ndim 0, dtype family int, 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
is_master_proc Ran
ran, violated the contract we drafted
damo-vilab/videocomposer/utils/distributed.py
code served (permissive licence) · get_code("30fda522caa99e6e")
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 bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.distributed as dist

torch.manual_seed(0)

# The function is_master_proc takes one parameter: num_gpus
# It checks if distributed training is initialized and uses get_rank() and modulo arithmetic
# If not initialized, it returns True
# We'll set up a simple case where distributed is not initialized

ARGS = {
    "num_gpus": 8
}
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 bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
kl_divergence Ran
ran on a synthesized input
damo-vilab/videocomposer/artist/ops/losses.py
code served (permissive licence) · get_code("24f8868cf6825433")
How it ran

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

import torch

torch.manual_seed(0)

# Create small tensors for the KL divergence function
# The function expects mu and logvar tensors (mean and log-variance)
# Batch size: 2, Dimension: 4

mu1 = torch.randn(2, 4)
logvar1 = torch.randn(2, 4)
mu2 = torch.randn(2, 4)
logvar2 = torch.randn(2, 4)

ARGS = {
    "mu1": mu1,
    "logvar1": logvar1,
    "mu2": mu2,
    "logvar2": logvar2,
}
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
model_wrapper Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
damo-vilab/videocomposer/artist/ops/dpm_solver.py
code served (permissive licence) · get_code("0e68c8747f1cfcd9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned function. 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)

# Create a minimal diffusion model
class SimpleNoiseModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, x, t_input, **kwargs):
        # x: [batch, 4], t_input: [batch] or scalar
        # Output noise prediction of same shape as x
        return self.linear(x)

# Create a minimal noise schedule
class SimpleNoiseSchedule:
    def __init__(self):
        self.T = 1.0
    
    def get_sigma(self, t):
        # Return sigma value for time t
        if isinstance(t, torch.Tensor):
            return torch.sqrt(1.0 - t)
        return (1.0 - t) ** 0.5

# Create a minimal classifier function
def simple_classifier_fn(x, t_input, cond, **kwargs):
    # x: [batch, 4], t_input: [batch], cond: [batch, 3]
    # Output logits
    batch_size = x.shape[0]
    return torch.randn(batch_size, 2)

# Create sample tensors
batch_size = 2
x_sample = torch.randn(batch_size, 4)
condition_sample = torch.randn(batch_size, 3)
unconditional_condition_sample = torch.zeros(batch_size, 3)

# Build the arguments dictionary
ARGS = {
    'model': SimpleNoiseModel(),
    'noise_schedule': SimpleNoiseSchedule(),
    'model_type': 'noise',
    'model_kwargs': {'extra_param': 0.5},
    'guidance_type': 'uncond',
    'condition': condition_sample,
    'unconditional_condition': unconditional_condition_sample,
    'guidance_scale': 7.5,
    'classifier_fn': simple_classifier_fn,
    'classifier_kwargs': {'classifier_param': 1.0},
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
model_wrapper_guided_diffusion Ran
ran on a synthesized input
damo-vilab/videocomposer/artist/ops/dpm_solver.py
code served (permissive licence) · get_code("c877d9da577fc0d3")
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 function. 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)

# Create a minimal noise schedule object
class NoiseScheduleVP:
    def __init__(self, schedule='discrete', total_N=1000):
        self.schedule = schedule
        self.total_N = total_N

# Create a minimal diffusion model that accepts (xt, t_input, **model_kwargs)
class MinimalDiffusionModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, xt, t_input, **model_kwargs):
        # xt shape: [batch, 4], t_input shape: [batch]
        # Returns predicted noise with same shape as xt
        return self.linear(xt)

# Create a minimal condition function for classifier guidance
def minimal_condition_fn(xt, t_input, **model_kwargs):
    # Returns logits, shape: [batch, 1]
    return torch.randn(xt.shape[0], 1)

# Build the arguments dictionary
ARGS = {
    'model': MinimalDiffusionModel(),
    'noise_schedule': NoiseScheduleVP(schedule='discrete', total_N=1000),
    'var_type': 'fixed_small',
    'mean_type': 'eps',
    'model_kwargs': {'class_labels': torch.randint(0, 10, (2,))},
    'rescale_timesteps': False,
    'num_timesteps': 1000,
    'guide_scale': 7.5,
    'condition_fn': minimal_condition_fn,
}
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 function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
nonlinearity Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from morganstanley/msml
pointer only · get_code("3137073275f8c21a")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

random_resize Ran
ran on a synthesized input
damo-vilab/videocomposer/gen_sketch.py
code served (permissive licence) · get_code("3194e97648f3e21e")
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 4, 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 torchvision.transforms.functional as TF
from PIL import Image
import numpy as np

torch.manual_seed(0)

# Create small PIL Images for testing
# The function expects a list of images that can be resized
img1 = Image.new('RGB', (8, 6), color='red')
img2 = Image.new('RGB', (8, 6), color='blue')

ARGS = {
    'img': [img1, img2],
    'size': (4, 3)
}
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 list, ndim 4, 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
single2uint Ran
ran on a synthesized input
damo-vilab/videocomposer/artist/ops/degration.py
code served (permissive licence) · get_code("83caf98edcef2e94")
How it ran

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

import numpy as np

# single2uint takes an image array and converts it to uint8
# The function clips values to [0, 1], scales by 255, rounds, and converts to uint8
# We need to pass a numpy array or array-like with float values

# Create a small test image with float values in [0, 1] range
img = np.array([
    [0.0, 0.5, 1.0, 0.25],
    [0.75, 0.1, 0.9, 0.3]
], dtype=np.float32)

ARGS = {
    'img': img
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family int, 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
standard_normal_cdf Ran
ran on a synthesized input
damo-vilab/videocomposer/artist/ops/losses.py
code served (permissive licence) · get_code("59f8d2f892f3195a")
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 math

torch.manual_seed(0)

# The function takes a single parameter 'x' which should be a torch tensor
# It performs mathematical operations on the tensor using torch operations
# so x needs to be a tensor that supports torch.tanh and torch.pow

x = torch.randn(2, 4)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 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
uint2single Ran
ran, violated the contract we drafted
damo-vilab/videocomposer/artist/ops/degration.py
code served (permissive licence) · get_code("9aa26711dc747d66")
How it ran

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

import numpy as np

# The function uint2single takes an image (numpy array of uint8 values)
# and converts it to float32 by dividing by 255.0
# We need to provide a small numpy array with uint8 dtype

img = np.array([[0, 85, 170, 255],
                [42, 127, 200, 230]], dtype=np.uint8)

ARGS = {
    'img': img
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 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
all_gather Not yet run
unverified (harvested, no recorded run)
damo-vilab/videocomposer/utils/distributed.py
code served (permissive licence) · get_code("a1ba6b0c4d96716f")
How it ran

no invocation recorded.

all_reduce Not yet run
unverified (harvested, no recorded run)
damo-vilab/videocomposer/utils/distributed.py
code served (permissive licence) · get_code("439067335e7b67b5")
How it ran

no invocation recorded.

imread_uint Not yet run
unverified (harvested, no recorded run)
damo-vilab/videocomposer/artist/ops/degration.py
code served (permissive licence) · get_code("57ba5b9dc5dfa8d3")
How it ran

no invocation recorded.

midas_v3 Not yet run
unverified (harvested, no recorded run)
damo-vilab/videocomposer/artist/models/midas.py
code served (permissive licence) · get_code("75297920dd4b445d")
How it ran

no invocation recorded.

new_group Not yet run
unverified (harvested, no recorded run)
damo-vilab/videocomposer/artist/ops/distributed.py
code served (permissive licence) · get_code("69723155a0580292")
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, 13 are also present in other papers whose code we hold (6 with at least one paper dated earlier, 3 the same month, 13 later) and 8 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
nonlinearity 156 other papers
36 dated earlier, 4 the same month, 115 later, 1 same year, order not determinable · 25 only as an assembly brick
2104.07652 (2021-04)
Geometry-Free View Synthesis: Transformers and no 3D Priors
2106.00132 (2021-06)
On Fast Sampling of Diffusion Probabilistic Models
2106.06819 (2021-06)
D2C: Diffusion-Denoising Models for Few-shot Conditional Generation
and 153 more not named here
Normalize 54 other papers
4 dated earlier, 2 the same month, 47 later, 1 same year, order not determinable · 3 only as an assembly brick
2204.06125 (2022-04)
Hierarchical Text-Conditional Image Generation with CLIP Latents
2208.13753 (2022-08)
Frido: Feature Pyramid Diffusion for Complex Scene Image Synthesis
2211.13221 (2022-11)
Latent Video Diffusion Models for High-Fidelity Long Video Generation
and 51 more not named here
interpolate_fn 34 other papers
6 dated earlier, 1 the same month, 27 later
2112.10752 (2021-12)
High-Resolution Image Synthesis with Latent Diffusion Models
2211.01095 (2022-11)
DPM-Solver++: Fast Solver for Guided Sampling of Diffusion Probabilistic Models
2212.09478 (2022-12)
MM-Diffusion: Learning Multi-Modal Diffusion Models for Joint Audio and Video Generation
and 31 more not named here
get_logger 8 other papers
3 dated earlier, 5 later
1905.13214 (2019-05)
On Network Design Spaces for Visual Recognition
2108.02927 (2021-08)
DOLG: Single-Stage Image Retrieval with Deep Orthogonal Fusion of Local and Global Features
2301.12132 (2023-01)
AutoPEFT: Automatic Configuration Search for Parameter-Efficient Fine-Tuning
and 5 more not named here
imread_uint 5 other papers
3 dated earlier, 1 later, 1 same year, order not determinable
2009.11551 (2020-09)
Residual Feature Distillation Network for Lightweight Image Super-Resolution
2110.03220 (2021-10)
Gradient Step Denoiser for convergent Plug-and-Play
2201.13256 (2022-01)
Proximal Denoiser for Convergent Plug-and-Play Optimization with Nonconvex Regularization
and 2 more not named here
model_wrapper 4 other papers
2 dated earlier, 2 later
2211.01095 (2022-11)
DPM-Solver++: Fast Solver for Guided Sampling of Diffusion Probabilistic Models
2302.04867 (2023-02)
UniPC: A Unified Predictor-Corrector Framework for Fast Sampling of Diffusion Models
2310.13268 (2023-10)
DPM-Solver-v3: Improved Diffusion ODE Solver with Empirical Model Statistics
and 1 more not named here
all_gather 2 other papers
2 later
2312.11973 (2023-12)
Continual Learning: Forget-free Winning Subnetworks for Video Representations
Pei_D2ST-Adapter_Disentangled-and-Deformable_Spatio-Temporal_Adapter_for_Few-shot_Action_Recognition_ICCV_2025_paper (2025 (year only))
D 2 ST-Adapter: Disentangled-and-Deformable Spatio-Temporal Adapter for Few-shot Action Recognition
all_reduce 2 other papers
2 later
2312.11973 (2023-12)
Continual Learning: Forget-free Winning Subnetworks for Video Representations
Pei_D2ST-Adapter_Disentangled-and-Deformable_Spatio-Temporal_Adapter_for_Few-shot_Action_Recognition_ICCV_2025_paper (2025 (year only))
D 2 ST-Adapter: Disentangled-and-Deformable Spatio-Temporal Adapter for Few-shot Action Recognition
get_rank 2 other papers
2 later
2312.09109 (2023-12)
VideoLCM: Video Latent Consistency Model
2410.24219 (2024-10)
Enhancing Motion in Text-to-Video Generation with Decomposed Encoding and Conditioning
get_world_size 2 other papers
2 later
2312.09109 (2023-12)
VideoLCM: Video Latent Consistency Model
2410.24219 (2024-10)
Enhancing Motion in Text-to-Video Generation with Decomposed Encoding and Conditioning
new_group 2 other papers
2 later
2312.09109 (2023-12)
VideoLCM: Video Latent Consistency Model
2410.24219 (2024-10)
Enhancing Motion in Text-to-Video Generation with Decomposed Encoding and Conditioning
is_master_proc 1 other paper
1 later
Pei_D2ST-Adapter_Disentangled-and-Deformable_Spatio-Temporal_Adapter_for_Few-shot_Action_Recognition_ICCV_2025_paper (2025 (year only))
D 2 ST-Adapter: Disentangled-and-Deformable Spatio-Temporal Adapter for Few-shot Action Recognition
uint2single 1 other paper
1 later
2405.04312 (2024-05)
Inf-DiT: Upsampling Any-Resolution Image with Memory-Efficient Diffusion Transformer

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

The pursuit of controllability as a higher standard of visual content creation has yielded remarkable progress in customizable image synthesis. However, achieving controllable video synthesis remains challenging due to the large variation of temporal dynamics and the requirement of cross-frame temporal consistency. Based on the paradigm of compositional generation, this work presents VideoComposer that allows users to flexibly compose a video with textual conditions, spatial conditions, and more importantly temporal conditions. Specifically, considering the characteristic of video data, we introduce the motion vector from compressed videos as an explicit control signal to provide guidance regarding temporal dynamics. In addition, we develop a Spatio-Temporal Condition encoder (STC-encoder) that serves as a unified interface to effectively incorporate the spatial and temporal relations of sequential inputs, with which the model could make better use of temporal conditions and hence achieve higher inter-frame consistency. Extensive experimental results suggest that VideoComposer is able to control the spatial and temporal patterns simultaneously within a synthesized video in various forms, such as text description, sketch sequence, reference video, or even simply hand-crafted motions. The code and models will be publicly available at https://videocomposer.github.io.

For agents

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

get_harvested_code_for_paper("2306.02018")
get_code_for_paper("2306.02018")
have("2306.02018")

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

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

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

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

Connect an agent — have() is free.