SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2405.16907 · NeurIPS · 2024

GTA: Generative Trajectory Augmentation with Guidance for Offline Reinforcement Learning

Jinkyoo Park, Taeyoung Yun, Jaewoo Lee, Sujin Yun, Omelet

arXiv · PDF · Open in the Atlas

Code that ran

34 of 37 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, 4 violated it and 1 has no contract verdict; 21 failures of our instrument; 3 no recorded run); 2 of them were also run on the host, not in the jail, by the peer-agreement lane that set their 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/2405.16907.json · badge: /api/ran/2405.16907.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
Jaewoopudding/GTA canonical (classifier label)
classifier basis: census
15 ran · 1 no recorded run
conglu1997/SynthER canonical (classifier label)
classifier basis: census
10 ran · 0 no recorded run
conglu1997/v-d4rl canonical (classifier label)
classifier basis: census
8 ran · 0 no recorded run
jaewoopudding/gta canonical (classifier label)
classifier basis: classifier_2025
1 ran · 2 no recorded run
FunctionStatusWhere it lives
compute_mean_std Ran
ran; our contract draft was wrong, not the code
conglu1997/SynthER/synther/corl/algorithms/cql.py
code served (permissive licence) · get_code("4e08ac58e3891cfb")
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 tuple, ndim 2, dtype family float; no output shape is stated. 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-04T23:42:44Z). 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 numpy as np

# Create a small numpy array with shape (batch_size=2, features=4)
states = np.random.randn(2, 4).astype(np.float32)

# Small epsilon value for numerical stability
eps = 1e-8

ARGS = {
    "states": states,
    "eps": eps,
}
Setup block drafted by
a language model, Claude Haiku 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 tuple, ndim 2, 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
log Ran
ran; our contract draft was wrong, not the code
conglu1997/SynthER/synther/diffusion/elucidated_diffusion.py
code served (permissive licence) · get_code("b5472673332de78e")
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, 4) 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-05T01:35:34Z). 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 takes a tensor `t` and an optional `eps` parameter
# It clamps the tensor to a minimum value of eps, then takes the log

# Create a small tensor with positive values (log requires positive input)
t = torch.tensor([[0.5, 1.0, 2.0, 0.1],
                   [0.3, 0.8, 1.5, 0.2]], dtype=torch.float32)

ARGS = {
    "t": t,
    "eps": 1e-20
}
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, 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
ElucidatedDiffusion Ran
ran on a synthesized input
jaewoopudding/gta/src/diffusion/elucidated_diffusion.py
code served (permissive licence) · get_code("01dc94ab923da1cc")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, 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
import torch.nn as nn
import math
from typing import Optional

# Mock normalizer
class MockNormalizer(nn.Module):
    def __init__(self):
        super().__init__()
    
    def normalize(self, x: torch.Tensor) -> torch.Tensor:
        return x
    
    def unnormalize(self, x: torch.Tensor) -> torch.Tensor:
        return x

# Mock network with required attribute
class MockNet(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.random_or_learned_sinusoidal_cond = True
        self.linear1 = nn.Linear(input_dim, 8)
        self.linear2 = nn.Linear(8, output_dim)
    
    def forward(self, x, sigma, cond=None):
        x = torch.relu(self.linear1(x))
        x = self.linear2(x)
        return x

# Create mock network
# data_shape will be: {'observations': (T=3, obs_dim=4), 'actions': (T=3, action_dim=5)}
# Total D = 4 + 5 = 9
# event_shape = [3, 9]
T = 3
obs_dim = 4
action_dim = 5
D = obs_dim + action_dim

mock_net = MockNet(input_dim=D, output_dim=D)
mock_normalizer = MockNormalizer()

data_shape = {
    'observations': (T, obs_dim),
    'actions': (T, action_dim)
}

INIT_ARGS = {
    'net': mock_net,
    'normalizer': mock_normalizer,
    'data_shape': data_shape,
    'num_sample_steps': 4,
    'sigma_min': 0.002,
    'sigma_max': 80.0,
    'sigma_data': 1.0,
    'rho': 7.0,
    'P_mean': -1.2,
    'P_std': 1.2,
    'S_churn': 80.0,
    'S_tmin': 0.05,
    'S_tmax': 50.0,
    'S_noise': 1.003
}

ARGS = {
    'batch_size': 2,
    'num_sample_steps': 4,
    'clamp': True,
    'cond': None,
    'disable_tqdm': True
}

METHOD = 'sample'
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
einops, torch, torchdiffeq, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
asymmetric_l2_loss Ran
ran; our contract draft was wrong, not the code
Jaewoopudding/GTA/corl/algorithms/iql.py
pointer only (licence: MIT); the stored copy get_code serves, from yassinech/caps, is pointer only (licence: NONE) · get_code("82a8f299419d4d83")
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 yassinech/caps, 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.

combine_two_tensors Ran
ran, honoured the contract we drafted
conglu1997/SynthER/synther/online/redq_rlpd_agent.py
code served (permissive licence) · get_code("4d84241d86cd513b")
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 (5, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from torch import Tensor

torch.manual_seed(0)

# Create two small tensors with distinct shapes for testing
tensor1 = Tensor(np.random.randn(2, 4).astype(np.float32))
tensor2 = Tensor(np.random.randn(3, 4).astype(np.float32))

ARGS = {
    "tensor1": tensor1,
    "tensor2": tensor2,
}
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 (5, 4) — shape (5, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_mean_std Ran
ran; our contract draft was wrong, not the code
Jaewoopudding/GTA/corl/shared/utils.py
code served (permissive licence) · get_code("86f2ca05d53e29f0")
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 2, 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 numpy as np

# Create a small numpy array of states
# Shape: (batch_size=2, feature_dim=4)
states = np.random.randn(2, 4).astype(np.float32)

# Small epsilon value for numerical stability
eps = 1e-8

ARGS = {
    "states": states,
    "eps": eps,
}
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 tuple, ndim 2, 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
default Ran
ran, violated the contract we drafted
conglu1997/SynthER/synther/diffusion/denoiser_network.py
code served (permissive licence) · get_code("d1ef6b8cb9a28a53")
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 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 torch

torch.manual_seed(0)

def exists(x):
    return x is not None

def default(val, d):
    if exists(val):
        return val
    return d() if callable(d) else d

# Test case 1: val is not None, should return val
val_1 = "test_value"
d_1 = lambda: "default_value"

# Test case 2: val is None, d is callable, should return d()
val_2 = None
d_2 = lambda: "computed_default"

# Test case 3: val is None, d is not callable, should return d
val_3 = None
d_3 = "static_default"

# Test case 4: val is a number
val_4 = 42
d_4 = 100

# Test case 5: val is a tensor
val_5 = torch.tensor([1.0, 2.0, 3.0])
d_5 = lambda: torch.tensor([0.0])

ARGS = {
    "val": val_1,
    "d": d_1
}
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 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
default Ran
ran, violated the contract we drafted
Jaewoopudding/GTA/src/diffusion/elucidated_diffusion.py
code served (permissive licence) · get_code("915fbeb88e13d4a3")
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 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.

def exists(val):
    return val is not None

def default(val, d):
    if exists(val):
        return val
    return d() if callable(d) else d

# Test case 1: val is None, d is a non-callable value
val_1 = None
d_1 = 42

# Test case 2: val exists, d is a callable
val_2 = "existing_value"
d_2 = lambda: "default_value"

# Test case 3: val is None, d is a callable
val_3 = None
d_3 = lambda: [1, 2, 3]

# We'll use test case 2 for the ARGS dict
ARGS = {
    'val': val_2,
    'd': d_2
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
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
define_rewardweighting_sampler Ran
ran; our contract draft was wrong, not the code
Jaewoopudding/GTA/src/diffusion/elucidated_diffusion.py
code served (permissive licence) · get_code("7606f8708b6efb13")
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 WeightedRandomSampler. 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
import torch
from torch.utils.data import DataLoader, WeightedRandomSampler

torch.manual_seed(0)

class MockDataset:
    def __init__(self):
        # For dense reward case ('maze' in dataset_nm)
        self.episode_rewards = np.array([0, 1, 0, 2], dtype=np.float64)
        # For sparse reward case (trajectory returns)
        self.trajectory_returns = np.array([0.5, 1.2, 0.3, 2.1], dtype=np.float64)

# Test with dense reward (maze dataset)
dataset_dense = MockDataset()
ARGS = {
    "dataset": dataset_dense,
    "dataset_nm": "maze_env",
    "reward_scale": 1.0,
    "weight_param": 5
}
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 WeightedRandomSampler — a WeightedRandomSampler output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a WeightedRandomSampler 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
discounted_cumsum Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Jaewoopudding/GTA/corl/algorithms/dt.py
code served (permissive licence) · get_code("f1082bd682dc3cf0")
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 1, dtype family float, shape (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

# Create a small numpy array for discounted cumsum
x = np.array([1.0, 2.0, 3.0, 4.0, 5.0])

# Set gamma (discount factor)
gamma = 0.99

ARGS = {
    "x": x,
    "gamma": gamma,
}
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 1, dtype family float, shape (5,) — shape (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
episode_len Ran
ran, honoured the contract we drafted
conglu1997/v-d4rl/drqbc/replay_buffer.py
code served (permissive licence) · get_code("9f840a22d31a89bc")
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

torch.manual_seed(0)

# The function accesses episode.values() and calls .shape[0] on the result
# So episode should be a dict where values are tensors (or array-like with shape)
# The function returns shape[0] - 1, so we need at least 1 element in dimension 0

episode = {
    "observations": torch.randn(5, 4),
    "actions": torch.randn(5, 3),
    "rewards": torch.randn(5, 2),
}

ARGS = {
    "episode": episode
}
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
eval_actor Ran
ran, honoured the contract we drafted
conglu1997/SynthER/synther/corl/algorithms/edac.py
code served (permissive licence) · get_code("7ca0a51383f3d84b")
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 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import numpy as np
import gym
from torch.distributions import Normal
from typing import Tuple, Optional

torch.manual_seed(0)

class Actor(nn.Module):

    def __init__(self, state_dim: int, action_dim: int, hidden_dim: int, max_action: float=1.0):
        super().__init__()
        self.trunk = nn.Sequential(nn.Linear(state_dim, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, hidden_dim), nn.ReLU())
        self.mu = nn.Linear(hidden_dim, action_dim)
        self.log_sigma = nn.Linear(hidden_dim, action_dim)
        for layer in self.trunk[::2]:
            torch.nn.init.constant_(layer.bias, 0.1)
        torch.nn.init.uniform_(self.mu.weight, -0.001, 0.001)
        torch.nn.init.uniform_(self.mu.bias, -0.001, 0.001)
        torch.nn.init.uniform_(self.log_sigma.weight, -0.001, 0.001)
        torch.nn.init.uniform_(self.log_sigma.bias, -0.001, 0.001)
        self.action_dim = action_dim
        self.max_action = max_action

    def forward(self, state: torch.Tensor, deterministic: bool=False, need_log_prob: bool=False) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
        hidden = self.trunk(state)
        mu, log_sigma = (self.mu(hidden), self.log_sigma(hidden))
        log_sigma = torch.clip(log_sigma, -5, 2)
        policy_dist = Normal(mu, torch.exp(log_sigma))
        if deterministic:
            action = mu
        else:
            action = policy_dist.rsample()
        tanh_action, log_prob = (torch.tanh(action), None)
        if need_log_prob:
            log_prob = policy_dist.log_prob(action).sum(axis=-1)
            log_prob = log_prob - torch.log(1 - tanh_action.pow(2) + 1e-06).sum(axis=-1)
        return (tanh_action * self.max_action, log_prob)

    @torch.no_grad()
    def act(self, state: np.ndarray, device: str) -> np.ndarray:
        deterministic = not self.training
        state = torch.tensor(state, device=device, dtype=torch.float32)
        action = self(state, deterministic=deterministic)[0].cpu().numpy()
        return action

class MockEnv(gym.Env):
    def __init__(self):
        self.state_dim = 4
        self.action_dim = 3
        self.observation_space = gym.spaces.Box(low=-1, high=1, shape=(self.state_dim,), dtype=np.float32)
        self.action_space = gym.spaces.Box(low=-1, high=1, shape=(self.action_dim,), dtype=np.float32)
    
    def seed(self, seed):
        np.random.seed(seed)
    
    def reset(self):
        return np.random.randn(self.state_dim).astype(np.float32)
    
    def step(self, action):
        state = np.random.randn(self.state_dim).astype(np.float32)
        reward = float(np.random.randn())
        done = np.random.rand() > 0.9
        info = {}
        return state, reward, done, info

env = MockEnv()
actor = Actor(state_dim=4, action_dim=3, hidden_dim=8, max_action=1.0)
device = 'cpu'
n_episodes = 2
seed = 42

ARGS = {
    'env': env,
    'actor': actor,
    'device': device,
    'n_episodes': n_episodes,
    'seed': seed
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
gym, 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 1, dtype family float, shape (2,) — shape (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
exists Ran
ran, violated the contract we drafted
Jaewoopudding/GTA/src/diffusion/elucidated_diffusion.py
pointer only (licence: MIT); the stored copy get_code serves, from ThomasMrY/VCT, is pointer only (licence: NONE) · get_code("aa5486a3650902d8")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from ThomasMrY/VCT, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

exists Ran
ran, violated the contract we drafted
conglu1997/SynthER/synther/diffusion/denoiser_network.py
code served (permissive licence) · get_code("608e364a9d2376a3")
How it ran

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

import torch

def exists(x):
    return x is not None

ARGS = {
    "x": torch.tensor([1, 2, 3, 4])
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
extend_and_repeat Ran
ran; our contract draft was wrong, not the code
Jaewoopudding/GTA/corl/algorithms/cql.py
pointer only (licence: MIT); the stored copy get_code serves, from QinwenLuo/OCR-CFT, is pointer only (licence: NONE) · get_code("a4d39c2adb56e8ce")
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 QinwenLuo/OCR-CFT, 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.

get_activation Ran
ran; our contract draft was wrong, not the code
Jaewoopudding/GTA/src/diffusion/denoiser_network/helpers.py
code served (permissive licence) · get_code("308e4d2dcc2d67f2")
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)

# Test case 1: params as a dict with type and kwargs
params_dict = {
    'type': 'ReLU',
    'kwargs': {}
}

# Test case 2: params as a string
params_string = 'Sigmoid'

# We'll use the dict case as the primary test
ARGS = {
    'params': params_dict
}
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
get_time_limit Ran
ran, honoured the contract we drafted
conglu1997/SynthER/synther/online/online_exp.py
code served (permissive licence) · get_code("996f00d5d9b562ae")
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 gym
from gym import spaces
import numpy as np

# Create a minimal gym.Env subclass with spec and max_episode_steps
class DummyEnv(gym.Env):
    def __init__(self):
        self.observation_space = spaces.Box(low=0, high=1, shape=(4,), dtype=np.float32)
        self.action_space = spaces.Discrete(2)
        
        # Create a minimal spec object
        class DummySpec:
            max_episode_steps = 100
        
        self.spec = DummySpec()
    
    def reset(self):
        return self.observation_space.sample()
    
    def step(self, action):
        obs = self.observation_space.sample()
        reward = 0.0
        done = False
        info = {}
        return obs, reward, done, info
    
    def render(self, mode='human'):
        pass

env = DummyEnv()

ARGS = {
    'env': env
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
gym, numpy — 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_unique_int Ran
ran, honoured the contract we drafted
conglu1997/v-d4rl/drqbc/dmc.py
pointer only (licence: MIT); the stored copy get_code serves, from manantomar/video-occupancy-models, is pointer only (licence: NONE) · get_code("52a34e88baa61a95")
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 manantomar/video-occupancy-models, 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.

load_episode Ran
ran; our contract draft was wrong, not the code
conglu1997/v-d4rl/drqbc/replay_buffer.py
code served (permissive licence) · get_code("184876e5f4ab6562")
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 numpy as np
from pathlib import Path
import tempfile
import os

# Create a temporary file to serve as the episode file
temp_dir = tempfile.mkdtemp()
temp_file_path = Path(temp_dir) / "episode.npz"

# Create a sample episode dictionary with numpy arrays
episode_data = {
    'observations': np.random.rand(5, 4).astype(np.float32),
    'actions': np.random.randint(0, 3, size=(5,)).astype(np.int32),
    'rewards': np.random.rand(5).astype(np.float32),
    'dones': np.random.randint(0, 2, size=(5,)).astype(bool),
}

# Save as npz file
np.savez(temp_file_path, **episode_data)

# Define ARGS with the file path
ARGS = {
    'fn': temp_file_path
}
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 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
load_episodes Ran
ran; our contract draft was wrong, not the code
conglu1997/v-d4rl/conversion_scripts/npz_to_hdf5.py
code served (permissive licence) · get_code("5ca2fd0c3f022a7d")
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 numpy as np
from pathlib import Path
import tempfile
import os

# Create a temporary directory with sample .npz files
temp_dir = tempfile.mkdtemp()
temp_path = Path(temp_dir)

# Create sample episode files with proper naming convention (name-length.npz)
# The function parses the filename to extract length as the number before .npz
episode1_data = {
    'discount': np.array([1.0, 1.0, 1.0]),
    'reward': np.array([0.5, 1.0, 0.0]),
    'observation': np.random.randn(3, 4)
}
np.savez(temp_path / 'episode_001-3.npz', **episode1_data)

episode2_data = {
    'discount': np.array([1.0, 1.0, 0.0]),
    'reward': np.array([0.2, 0.8, 1.0]),
    'observation': np.random.randn(3, 4),
    'is_terminal': np.array([False, False, True])
}
np.savez(temp_path / 'episode_002-3.npz', **episode2_data)

episode3_data = {
    'discount': np.array([1.0, 0.0]),
    'reward': np.array([0.1, 0.0]),
    'observation': np.random.randn(2, 4)
}
np.savez(temp_path / 'episode_003-2.npz', **episode3_data)

ARGS = {
    'directory': temp_path,
    'capacity': None
}
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 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
make_replay_loader Ran
ran; our contract draft was wrong, not the code
conglu1997/v-d4rl/drqbc/replay_buffer.py
code served (permissive licence) · get_code("6567f3b84283c0f8")
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 DataLoader. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
import tempfile
from pathlib import Path
import random

torch.manual_seed(0)
np.random.seed(0)
random.seed(0)

# Create a temporary directory for replay files
temp_dir = tempfile.TemporaryDirectory()
replay_dir = Path(temp_dir.name)

# Create minimal episode files in the replay directory
# Episodes need: observation, action, reward, discount keys
for ep_idx in range(2):
    episode_data = {
        'observation': np.random.randn(10, 4).astype(np.float32),  # 10 timesteps, 4-dim obs
        'action': np.random.randn(10, 3).astype(np.float32),       # 10 timesteps, 3-dim action
        'reward': np.random.randn(10, 1).astype(np.float32),       # 10 timesteps, 1-dim reward
        'discount': np.ones((10, 1), dtype=np.float32),            # 10 timesteps, discount factor
    }
    
    # Save as npz file with naming convention: episode_{ep_idx}_{episode_len}.npz
    ep_len = episode_data['observation'].shape[0] - 1
    episode_path = replay_dir / f"episode_{ep_idx}_{ep_len}.npz"
    np.savez(episode_path, **episode_data)

ARGS = {
    'replay_dir': replay_dir,
    'max_size': 1000,
    'batch_size': 2,
    'num_workers': 0,
    'save_snapshot': False,
    'nstep': 3,
    'discount': 0.99,
}
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 DataLoader — a DataLoader output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataLoader 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
normalize_states Ran
ran, honoured the contract we drafted
Jaewoopudding/GTA/corl/shared/utils.py
code served (permissive licence) · get_code("ba80f9ff81b1de5f")
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 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

# Create sample states array with shape (batch_size=2, state_dim=4)
states = np.array([
    [1.0, 2.0, 3.0, 4.0],
    [5.0, 6.0, 7.0, 8.0]
], dtype=np.float32)

# Create mean array with shape (4,)
mean = np.array([3.0, 4.0, 5.0, 6.0], dtype=np.float32)

# Create std array with shape (4,)
std = np.array([1.0, 1.0, 1.0, 1.0], dtype=np.float32)

ARGS = {
    "states": states,
    "mean": mean,
    "std": std
}
Setup block drafted by
a language model, Claude Haiku 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 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
normalizer_factory Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
conglu1997/SynthER/synther/diffusion/norm.py
code served (permissive licence) · get_code("be9e2d491a0432c5")
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 MinMaxNormalizer. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a small dataset tensor for normalization
# Shape: (batch_size=2, features=4)
dataset = torch.randn(2, 4)

# Test with 'minmax' normalizer
ARGS = {
    'normalizer_type': 'minmax',
    'dataset': dataset,
    'skip_dims': None,
}
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 MinMaxNormalizer — a MinMaxNormalizer output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MinMaxNormalizer 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
pad_along_axis Ran
ran; our contract draft was wrong, not the code
Jaewoopudding/GTA/corl/algorithms/dt.py
code served (permissive licence) · get_code("47482b0dd3325c35")
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 (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 numpy as np

# Create a small test array with distinct dimensions to make shape probing unambiguous
arr = np.random.randn(4, 3)

# Parameters for pad_along_axis
ARGS = {
    "arr": arr,
    "pad_to": 7,
    "axis": 0,
    "fill_value": 0.0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (7, 3) — shape (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
return_reward_range Ran
ran, honoured the contract we drafted
Jaewoopudding/GTA/corl/shared/buffer.py
code served (permissive licence) · get_code("136a4348dc060901")
How it ran

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

# Create a small dataset with rewards and terminals
# The function expects dataset to be a dict with 'rewards' and 'terminals' keys
# It iterates through them with zip, so they should be sequences of the same length

# Let's create a dataset with 2 complete episodes and one partial episode
# Episode 1: 3 steps, rewards [1.0, 2.0, 3.0], terminal at end
# Episode 2: 2 steps, rewards [0.5, 1.5], terminal at end
# Episode 3: 1 step (incomplete), rewards [2.0], no terminal

rewards = [1.0, 2.0, 3.0, 0.5, 1.5, 2.0]
terminals = [False, False, True, False, True, False]

dataset = {
    'rewards': rewards,
    'terminals': terminals
}

max_episode_steps = 5

ARGS = {
    'dataset': dataset,
    'max_episode_steps': max_episode_steps
}
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 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
save_episode Ran
ran; our contract draft was wrong, not the code
conglu1997/v-d4rl/conversion_scripts/hdf5_to_npz.py
code served (permissive licence) · get_code("a5da65c6813c8a2e")
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 PosixPath. 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 datetime
import io
import uuid
import numpy as np
from pathlib import Path
import tempfile

# Create a temporary directory for the test
temp_dir = tempfile.TemporaryDirectory()
directory = Path(temp_dir.name)

# Construct a valid episode dictionary with numpy arrays
episode = {
    'action': np.array([[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]], dtype=np.float32),
    'observation': np.array([[1, 2, 3, 4], [5, 6, 7, 8]], dtype=np.int32),
    'reward': np.array([1.0, 2.0], dtype=np.float32),
    'done': np.array([False, True], dtype=bool),
}

ARGS = {
    'directory': directory,
    'episode': episode,
}
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 PosixPath — a PosixPath output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PosixPath 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
schedule Ran
ran, honoured the contract we drafted
conglu1997/v-d4rl/drqbc/utils.py
code served (permissive licence) · get_code("ae234269debed3f4")
How it ran

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

import re
import numpy as np

# Test case 1: simple float string
ARGS = {
    "schdl": "0.5",
    "step": 10
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
split_diffusion_trajectory Ran
ran; our contract draft was wrong, not the code
Jaewoopudding/GTA/src/diffusion/utils.py
code served (permissive licence) · get_code("f3eb5978a6086471")
How it ran

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

import torch
import numpy as np
import gym

torch.manual_seed(0)

# Create a simple gym environment with Box spaces
class SimpleEnv(gym.Env):
    def __init__(self):
        self.observation_space = gym.spaces.Box(low=-1, high=1, shape=(4,), dtype=np.float32)
        self.action_space = gym.spaces.Box(low=-1, high=1, shape=(3,), dtype=np.float32)

env = SimpleEnv()

# Build samples tensor: shape (batch=2, time=5, features=8)
# features = obs_dim(4) + act_dim(3) + rewards(1)
samples = torch.randn(2, 5, 8, dtype=torch.float32)

modalities = ['observations', 'actions', 'rewards']

ARGS = {
    'samples': samples,
    'env': env,
    'modalities': modalities
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
gym, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
split_diffusion_transition Ran
ran; our contract draft was wrong, not the code
Jaewoopudding/GTA/src/diffusion/utils.py
code served (permissive licence) · get_code("254a3bde31e8eccb")
How it ran

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

import torch
import numpy as np
import gym

torch.manual_seed(0)

# Create a simple gym environment
env = gym.make('Pendulum-v1')

# Get dimensions from environment
obs_dim = env.observation_space.shape[0]  # 3 for Pendulum
action_dim = env.action_space.shape[0]    # 1 for Pendulum

# Create sample data: (obs, action, reward, next_obs, [terminal])
# Total columns: obs_dim + action_dim + 1 (reward) + 1 (next_obs_start) + obs_dim + [1 for terminal]

# Test case 1: without modelled_terminals
batch_size = 2
total_cols_without_terminal = obs_dim + action_dim + 1 + obs_dim
samples_without_terminal = np.random.randn(batch_size, total_cols_without_terminal).astype(np.float32)

# Test case 2: with modelled_terminals
total_cols_with_terminal = obs_dim + action_dim + 1 + obs_dim + 1
samples_with_terminal = np.random.randn(batch_size, total_cols_with_terminal).astype(np.float32)

# Also create torch tensor version
samples_torch = torch.from_numpy(samples_with_terminal).float()

ARGS = {
    "samples": samples_torch,
    "env": env,
    "modelled_terminals": True,
    "terminal_threshold": 0.5
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
gym, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
to_torch Ran
ran; our contract draft was wrong, not the code
conglu1997/v-d4rl/drqbc/utils.py
pointer only (licence: MIT); the stored copy get_code serves, from premiertaco/premier-taco, is pointer only (licence: NONE) · get_code("6244e9922f4e0610")
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 premiertaco/premier-taco, 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.

wrap_env Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
conglu1997/SynthER/synther/corl/algorithms/cql.py
code served (permissive licence) · get_code("4dd56ecf0f797666")
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 TransformReward. 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 gym
import numpy as np

# Create a simple gym environment
env = gym.make('CartPole-v1')

# Define state normalization parameters
state_mean = np.array([0.1, 0.2, 0.3, 0.4])
state_std = np.array([0.5, 0.6, 0.7, 0.8])

# Define reward scale
reward_scale = 2.0

ARGS = {
    "env": env,
    "state_mean": state_mean,
    "state_std": state_std,
    "reward_scale": reward_scale,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
gym, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type TransformReward — a TransformReward output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a TransformReward 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
wrap_env Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Jaewoopudding/GTA/corl/algorithms/dt.py
code served (permissive licence) · get_code("637dc1e936615e64")
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 TransformReward. 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 gym
import numpy as np

# Create a simple gym environment
env = gym.make('CartPole-v1')

# Define state normalization parameters
state_mean = np.array([0.1, 0.2, 0.3, 0.4])
state_std = np.array([0.5, 0.6, 0.7, 0.8])

# Define reward scale
reward_scale = 2.0

ARGS = {
    'env': env,
    'state_mean': state_mean,
    'state_std': state_std,
    'reward_scale': reward_scale
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
gym, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type TransformReward — a TransformReward output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a TransformReward 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
wrap_env Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Jaewoopudding/GTA/corl/shared/utils.py
code served (permissive licence) · get_code("92425c08adf4c962")
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 TransformReward. 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
import gym

# Create a simple gym environment
env = gym.make('CartPole-v1')

# Define state normalization parameters
state_mean = np.array([0.1, 0.2, 0.3, 0.4])
state_std = np.array([0.5, 0.6, 0.7, 0.8])

# Define reward scale
reward_scale = 2.0

ARGS = {
    "env": env,
    "state_mean": state_mean,
    "state_std": state_std,
    "reward_scale": reward_scale,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
gym, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type TransformReward — a TransformReward output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a TransformReward 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
wrap_gym Ran
ran; our contract draft was wrong, not the code
conglu1997/SynthER/synther/online/online_exp.py
code served (permissive licence) · get_code("e06e791cc82d11d9")
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 ClipAction. 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 gym
from gym.spaces import Box, Dict
import numpy as np

# Create a simple gym environment with Dict observation space
class SimpleEnv(gym.Env):
    def __init__(self):
        self.observation_space = Dict({
            'position': Box(low=-1, high=1, shape=(3,), dtype=np.float32),
            'velocity': Box(low=-1, high=1, shape=(2,), dtype=np.float32)
        })
        self.action_space = Box(low=-2, high=2, shape=(4,), dtype=np.float32)
        self.reward_range = (-1, 1)
    
    def reset(self):
        return {
            'position': np.array([0.0, 0.0, 0.0], dtype=np.float32),
            'velocity': np.array([0.0, 0.0], dtype=np.float32)
        }
    
    def step(self, action):
        obs = {
            'position': np.array([0.1, 0.1, 0.1], dtype=np.float32),
            'velocity': np.array([0.0, 0.0], dtype=np.float32)
        }
        reward = 0.0
        done = False
        info = {}
        return obs, reward, done, info
    
    def render(self, mode='human'):
        pass

env = SimpleEnv()

ARGS = {
    'env': env,
    'rescale_actions': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
gym, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ClipAction — a ClipAction output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ClipAction 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
BaseNormalizer Not yet run
unverified (harvested, no recorded run)
jaewoopudding/gta/src/diffusion/elucidated_diffusion.py
code served (permissive licence) · get_code("463193b720793e28")
How it ran

no invocation recorded.

apply_conditioning Not yet run
unverified (harvested, no recorded run)
jaewoopudding/gta/src/diffusion/elucidated_diffusion.py
code served (permissive licence) · get_code("f723bf01040101db")
How it ran

no invocation recorded.

prepare_replay_buffer Not yet run
unverified (harvested, no recorded run)
Jaewoopudding/GTA/corl/shared/buffer.py
code served (permissive licence) · get_code("b02ea4837cdfa314")
How it ran

no invocation recorded.

Also present in other papers' code

Of 37 samples lifted from this paper's linked repositories, 37 carry a function identity and 0 do not. Of the 33 distinct functions with an identity, 21 are also present in other papers whose code we hold (18 with at least one paper dated earlier, 11 the same month, 17 later) and 12 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
exists
brick of this paper's assembly: helper
486 other papers
336 dated earlier, 11 the same month, 128 later, 9 same year, order not determinable, 2 undated · 78 only as an assembly brick
1603.08155 (2016-03)
Perceptual Losses for Real-Time Style Transfer and Super-Resolution
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1804.04637 (2018-04)
EMBER: An Open Dataset for Training Static PE Malware Machine Learning Models
and 483 more not named here
exists 144 other papers
82 dated earlier, 3 the same month, 54 later, 5 same year, order not determinable · 40 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1711.11585 (2017-11)
High-Resolution Image Synthesis and Semantic Manipulation with Conditional GANs
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
and 141 more not named here
default
brick of this paper's assembly: helper
79 other papers
41 dated earlier, 1 the same month, 34 later, 3 same year, order not determinable · 15 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
2010.02502 (2020-10)
Denoising Diffusion Implicit Models
and 76 more not named here
to_torch 23 other papers
18 dated earlier, 3 the same month, 2 later · 7 only as an assembly brick
2103.04551 (2021-03)
Behavior From the Void: Unsupervised Active Pre-Training
2107.09645 (2021-07)
Mastering Visual Continuous Control: Improved Data-Augmented Reinforcement Learning
2202.10324 (2022-02)
VRL3: A Data-Driven Framework for Visual Deep Reinforcement Learning
and 20 more not named here
log
brick of this paper's assembly: helper
22 other papers
16 dated earlier, 6 later · 9 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1907.05242 (2019-07)
Large Memory Layers with Product Keys
2203.07852 (2022-03)
Block-Recurrent Transformers
and 19 more not named here
schedule 17 other papers
15 dated earlier, 2 later · 7 only as an assembly brick
2103.04551 (2021-03)
Behavior From the Void: Unsupervised Active Pre-Training
2107.09645 (2021-07)
Mastering Visual Continuous Control: Improved Data-Augmented Reinforcement Learning
2202.10324 (2022-02)
VRL3: A Data-Driven Framework for Visual Deep Reinforcement Learning
and 14 more not named here
normalize_states 14 other papers
8 dated earlier, 1 the same month, 5 later
2106.06860 (2021-06)
A Minimalist Approach to Offline Reinforcement Learning
2210.07105 (2022-10)
CORL: Research-oriented Deep Offline Reinforcement Learning Library
2303.06614 (2023-03)
Synthetic Experience Replay
and 11 more not named here
compute_mean_std 12 other papers
7 dated earlier, 1 the same month, 4 later
2106.06860 (2021-06)
A Minimalist Approach to Offline Reinforcement Learning
2210.07105 (2022-10)
CORL: Research-oriented Deep Offline Reinforcement Learning Library
2303.06614 (2023-03)
Synthetic Experience Replay
and 9 more not named here
episode_len 12 other papers
7 dated earlier, 2 the same month, 3 later
2107.09645 (2021-07)
Mastering Visual Continuous Control: Improved Data-Augmented Reinforcement Learning
2211.12740 (2022-11)
Masked Autoencoding for Scalable and Generalizable Decision Making
2302.00965 (2023-02)
Visual Imitation Learning with Patch Rewards
and 9 more not named here
load_episode 10 other papers
5 dated earlier, 2 the same month, 3 later
2107.09645 (2021-07)
Mastering Visual Continuous Control: Improved Data-Augmented Reinforcement Learning
2302.00965 (2023-02)
Visual Imitation Learning with Patch Rewards
2303.01497 (2023-03)
Teach a Robot to FISH: Versatile Imitation from One Minute of Demonstrations
and 7 more not named here
asymmetric_l2_loss 7 other papers
2 dated earlier, 5 later · 3 only as an assembly brick
2110.06169 (2021-10)
Offline Reinforcement Learning with Implicit Q-Learning
2310.12955 (2023-10)
Towards Robust Offline Reinforcement Learning under Diverse Data Corruption
2410.20750 (2024-10)
ODRL: A Benchmark for Off-Dynamics Reinforcement Learning
and 4 more not named here
wrap_env 6 other papers
3 dated earlier, 1 the same month, 2 later
2305.09836 (2023-05)
Revisiting the Minimalist Approach to Offline Reinforcement Learning
2309.16973 (2023-09)
Towards Robust Offline-to-Online Reinforcement Learning via Uncertainty and Smoothness
2310.14550 (2023-10)
Corruption-Robust Offline Reinforcement Learning with General Function Approximation
and 3 more not named here
make_replay_loader 3 other papers
2 dated earlier, 1 the same month
2107.09645 (2021-07)
Mastering Visual Continuous Control: Improved Data-Augmented Reinforcement Learning
2303.01497 (2023-03)
Teach a Robot to FISH: Versatile Imitation from One Minute of Demonstrations
2405.17416 (2024-05)
A Recipe for Unbounded Data Augmentation in Visual Reinforcement Learning
return_reward_range 3 other papers
2 dated earlier, 1 later
2305.09836 (2023-05)
Revisiting the Minimalist Approach to Offline Reinforcement Learning
2309.16973 (2023-09)
Towards Robust Offline-to-Online Reinforcement Learning via Uncertainty and Smoothness
2407.12448 (2024-07)
Energy-Guided Diffusion Sampling for Offline-to-Online Reinforcement Learning
discounted_cumsum 2 other papers
1 dated earlier, 1 later
2305.09836 (2023-05)
Revisiting the Minimalist Approach to Offline Reinforcement Learning
2602.08584 (2026-02)
Conditional Sequence Modeling for Safe Reinforcement Learning
eval_actor 2 other papers
2 dated earlier
2309.16973 (2023-09)
Towards Robust Offline-to-Online Reinforcement Learning via Uncertainty and Smoothness
2310.14550 (2023-10)
Corruption-Robust Offline Reinforcement Learning with General Function Approximation
extend_and_repeat 2 other papers
1 the same month, 1 later · 1 only as an assembly brick
2405.17477 (2024-05)
OLLIE: Imitation Learning from Offline Pretraining to Online Finetuning
2412.18855 (2024-12)
Optimistic Critic Reconstruction and Constrained Fine-Tuning for General Offline-to-Online RL
get_activation 1 other paper
1 dated earlier
2106.02039 (2021-06)
Offline Reinforcement Learning as One Big Sequence Modeling Problem
get_unique_int 1 other paper
1 later
2407.09533 (2024-07)
Video Occupancy Models
load_episodes 1 other paper
1 later
2411.04562 (2024-11)
Constrained Latent Action Policies for Model-Based Offline Reinforcement Learning

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

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

Abstract

Offline Reinforcement Learning (Offline RL) presents challenges of learning effective decision-making policies from static datasets without any online interactions. Data augmentation techniques, such as noise injection and data synthesizing, aim to improve Q-function approximation by smoothing the learned state-action region. However, these methods often fall short of directly improving the quality of offline datasets, leading to suboptimal results. In response, we introduce GTA, Generative Trajectory Augmentation, a novel generative data augmentation approach designed to enrich offline data by augmenting trajectories to be both high-rewarding and dynamically plausible. GTA applies a diffusion model within the data augmentation framework. GTA partially noises original trajectories and then denoises them with classifier-free guidance via conditioning on amplified return value. Our results show that GTA, as a general data augmentation strategy, enhances the performance of widely used offline RL algorithms across various tasks with unique challenges. Furthermore, we conduct a quality analysis of data augmented by GTA and demonstrate that GTA improves the quality of the data. Our code is available at https://github.com/Jaewoopudding/GTA * Equal contribution authors. 38th Conference on Neural Information Processing Systems (NeurIPS 2024).

For agents

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

get_harvested_code_for_paper("2405.16907")
get_code_for_paper("2405.16907")
have("2405.16907")

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

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

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

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

Connect an agent — have() is free.