SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1312.5602 · arXiv.org · 2013

Playing Atari with Deep Reinforcement Learning

Volodymyr Mnih, David Silver, Ioannis Antonoglou, Martin Riedmiller, Koray Kavukcuoglu, Alex Graves, Daan Wierstra

arXiv · PDF · Open in the Atlas

Code that ran

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

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1312.5602.json · badge: /api/ran/1312.5602.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
tensorpack/tensorpack community
not in the paper's declared repositories
9 ran · 4 no recorded run
proroklab/popgym community
not in the paper's declared repositories
7 ran · 7 no recorded run
borhanreo/Obstacle-Avoid-Car community (classifier label)
classifier basis not recorded on the link
5 ran · 0 no recorded run
Sheepsody/Batched-Impala-PyTorch community
Papers with Code archive
4 ran · 3 no recorded run
michaelnny/deep_rl_zoo community
not in the paper's declared repositories
3 ran · 2 no recorded run
chandar-lab/RLHive community
not in the paper's declared repositories
3 ran · 2 no recorded run
TheFebrin/DeepRL-Pong community
not in the paper's declared repositories
3 ran · 0 no recorded run
parilo/rl-server community
not in the paper's declared repositories
2 ran · 3 no recorded run
BH4/Deep-Reinforcement-Learning community
Papers with Code archive
2 ran · 0 no recorded run
alfredvc/paac community
not in the paper's declared repositories
1 ran · 8 no recorded run
bay3s/dqn community
not in the paper's declared repositories
1 ran · 2 no recorded run
RLeike/connect-four community
Papers with Code archive
1 ran · 2 no recorded run
JonasRSV/DQNTensorflow community
Papers with Code archive
1 ran · 1 no recorded run
Linging/Traffic-Signal-Control community
Papers with Code archive
1 ran · 1 no recorded run
invictos/InsacarDQN community
not in the paper's declared repositories
1 ran · 1 no recorded run
KavindaKottege/DeepQ-Pong community
Papers with Code archive
1 ran · 1 no recorded run
eublefar/dqn community
not in the paper's declared repositories
1 ran · 1 no recorded run
avillemin/Minecraft-AI community
not in the paper's declared repositories
1 ran · 0 no recorded run
qiankun214/DQN-FlappyBird-python3 community
not in the paper's declared repositories
1 ran · 0 no recorded run
MaximeVandegar/Papers-in-100-Lines-of-Code community
not in the paper's declared repositories
1 ran · 0 no recorded run
daviddcho/supermario community
not in the paper's declared repositories
1 ran · 0 no recorded run
gordicaleksa/pytorch-learn-reinforcement-learning community
not in the paper's declared repositories
1 ran · 0 no recorded run
K-tang-mkv/baseRLAlgorithm community
Papers with Code archive
1 ran · 0 no recorded run
vincentpalma/DQN-for-CaRL community
not in the paper's declared repositories
1 ran · 0 no recorded run
kmdanielduan/DQN_Family_PyTorch community
not in the paper's declared repositories
1 ran · 0 no recorded run
FunctionStatusWhere it lives
BaseBlock Ran
ran on a synthesized input · constructed an object; no result was computed
Sheepsody/Batched-Impala-PyTorch/src/networks/ActorCritic.py
pointer only (licence: NONE) · get_code("69b2f2e5a6967e4c")
How it ran

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

Brain Ran
ran on a synthesized input
avillemin/Minecraft-AI/DQN/Agent.py
pointer only (licence: NONE) · get_code("8da78c4bfe306c3e")
How it ran

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

BrainDQN Ran
ran on a synthesized input · constructed an object; no result was computed
qiankun214/DQN-FlappyBird-python3/BrainDQN.py
pointer only (licence: NONE) · get_code("81c2538f25d49bf5")
How it ran

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

DQN Ran
ran on a synthesized input · constructed an object; no result was computed
bay3s/dqn/src/agents/dqn.py
pointer only (licence: NONE) · get_code("9c1d06fe674d019d")
How it ran

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

DQN Ran
ran on a synthesized input · constructed an object; no result was computed
TheFebrin/DeepRL-Pong/models/dqn_model.py
code served (permissive licence) · get_code("a54a3b810f63e7d1")
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 an instance of its own class, DQN: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    'in_channels': 4,
    'out_dim': 3,
    'criterion': nn.MSELoss()
}
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 DQN — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DQN 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
DQN Ran
ran on a synthesized input · constructed an object; no result was computed
MaximeVandegar/Papers-in-100-Lines-of-Code/Playing_Atari_with_Deep_Reinforcement_Learning/dqn.py
code served (permissive licence) · get_code("cc31fb79a4c9cfad")
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 an instance of its own class, DQN: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    "nb_actions": 18
}
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 DQN — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DQN 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
DQN Ran
ran on a synthesized input · constructed an object; no result was computed
daviddcho/supermario/model.py
pointer only (licence: NONE) · get_code("e65d2c13d9aa7641")
How it ran

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

DQN Ran
ran on a synthesized input · constructed an object; no result was computed
gordicaleksa/pytorch-learn-reinforcement-learning/models/definitions/DQN.py
code served (permissive licence) · get_code("51cf7eff17d1081c")
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 an instance of its own class, DQN: the run constructed the object and did not call it, so no result was computed. 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
import numpy as np
from gym import Env, spaces

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

class DummyEnv(Env):
    """Minimal gym-like environment for testing DQN"""
    def __init__(self):
        self.observation_space = spaces.Box(low=0, high=255, shape=(1, 84, 84), dtype=np.uint8)
        self.action_space = spaces.Discrete(3)
    
    def reset(self):
        return self.observation_space.sample()
    
    def step(self, action):
        return self.observation_space.sample(), 0, False, {}
    
    def render(self):
        pass

def epsilon_schedule_fn(step):
    """Simple linear decay epsilon schedule"""
    return max(0.01, 1.0 - step / 1000.0)

env = DummyEnv()

ARGS = {
    "env": env,
    "num_in_channels": 4,
    "number_of_actions": 3,
    "epsilon_schedule": epsilon_schedule_fn,
}
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 DQN — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DQN 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
DQN Ran
ran on a synthesized input
K-tang-mkv/baseRLAlgorithm/algorithms/DQN_pytorch_offical/dqn.py
pointer only (licence: NONE) · get_code("7ac5ee56c6e889b6")
How it ran

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

DQN Ran
ran on a synthesized input
vincentpalma/DQN-for-CaRL/dqn_training.py
pointer only (licence: NONE) · get_code("c7a2e9b74e4de596")
How it ran

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

DQN_Conv Ran
ran on a synthesized input · constructed an object; no result was computed
kmdanielduan/DQN_Family_PyTorch/networks.py
pointer only (licence: NONE) · get_code("9dc82f090fea3bda")
How it ran

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

DqnConvNet Ran
ran on a synthesized input
michaelnny/deep_rl_zoo/deep_rl_zoo/networks/value.py
code served (permissive licence) · get_code("73b097a72c5ea2f5")
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 DqnNetworkOutputs. 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
from typing import NamedTuple, Tuple
import math
import types as _types

class DqnNetworkOutputs(NamedTuple):
    q_values: torch.Tensor

def calc_conv2d_output(h_w: Tuple, kernel_size: int=1, stride: int=1, pad: int=0, dilation: int=1) -> Tuple[int, int]:
    """Takes a tuple of (h,w) and returns a tuple of (h,w)"""
    if not isinstance(kernel_size, Tuple):
        kernel_size = (kernel_size, kernel_size)
    h = math.floor((h_w[0] + 2 * pad - dilation * (kernel_size[0] - 1) - 1) / stride + 1)
    w = math.floor((h_w[1] + 2 * pad - dilation * (kernel_size[1] - 1) - 1) / stride + 1)
    return (h, w)

def initialize_weights(net: nn.Module) -> None:
    """Initialize weights for Conv2d and Linear layers using kaiming initializer."""
    assert isinstance(net, nn.Module)
    for module in net.modules():
        if isinstance(module, (nn.Conv2d, nn.Linear)):
            nn.init.kaiming_uniform_(module.weight, nonlinearity='relu')
            if module.bias is not None:
                nn.init.zeros_(module.bias)

class NatureCnnBackboneNet(nn.Module):
    """DQN Nature paper conv2d layers backbone, returns feature representation vector."""

    def __init__(self, state_dim: tuple) -> None:
        super().__init__()
        c, h, w = state_dim
        h, w = calc_conv2d_output((h, w), 8, 4)
        h, w = calc_conv2d_output((h, w), 4, 2)
        h, w = calc_conv2d_output((h, w), 3, 1)
        self.out_features = 64 * h * w
        self.net = nn.Sequential(
            nn.Conv2d(in_channels=c, out_channels=32, kernel_size=8, stride=4),
            nn.ReLU(),
            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=4, stride=2),
            nn.ReLU(),
            nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1),
            nn.ReLU(),
            nn.Flatten()
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """Given raw state images, returns feature representation vector"""
        return self.net(x)

class DqnConvNet(nn.Module):
    """DQN Conv2d network."""

    def __init__(self, state_dim: tuple, action_dim: int):
        """
        Args:
            state_dim: the shape of the input tensor to the neural network
            action_dim: the number of units for the output liner layer
        """
        if action_dim < 1:
            raise ValueError(f'Expect action_dim to be a positive integer, got {action_dim}')
        if len(state_dim) != 3:
            raise ValueError(f'Expect state_dim to be a tuple with [C, H, W], got {state_dim}')
        super().__init__()
        self.action_dim = action_dim
        self.body = NatureCnnBackboneNet(state_dim)
        self.value_head = nn.Sequential(
            nn.Linear(self.body.out_features, 512),
            nn.ReLU(),
            nn.Linear(512, action_dim)
        )
        initialize_weights(self)

    def forward(self, x: torch.Tensor) -> DqnNetworkOutputs:
        """Given state, return state-action value for all possible actions"""
        x = x.float() / 255.0
        x = self.body(x)
        q_values = self.value_head(x)
        return DqnNetworkOutputs(q_values=q_values)


INIT_ARGS = {
    'state_dim': (3, 84, 84),
    'action_dim': 4
}

ARGS = {
    'x': torch.randint(0, 256, (2, 3, 84, 84), dtype=torch.uint8)
}

if __name__ == '__main__':
    model = DqnConvNet(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output q_values shape: {output.q_values.shape}")
    print(f"Output q_values: {output.q_values}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DqnNetworkOutputs — a DqnNetworkOutputs 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
DropoutNd Ran
ran on a synthesized input · constructed an object; no result was computed
proroklab/popgym/popgym/baselines/models/s4d.py
code served (permissive licence) · get_code("f67fec3bfe6045aa")
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 an instance of its own class, DropoutNd: the run constructed the object and did not call it, so no result was computed. 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 small input tensor for testing
# Shape: (batch=2, dim=4, length=3) - typical for transposed format
X = torch.randn(2, 4, 3)

ARGS = {
    'p': 0.5,
    'tie': True,
    'transposed': True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DropoutNd — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DropoutNd 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
DuelingDQN Ran
ran on a synthesized input · constructed an object; no result was computed
SayhoKim/tetrisRL/lib/models/ddqn.py
pointer only (licence: NONE) · get_code("8eceb653c628a651")
How it ran

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

ExperienceReplay Ran
ran on a synthesized input · constructed an object; no result was computed
BH4/Deep-Reinforcement-Learning/Training/qlearn.py
code served (permissive licence) · get_code("f9118b06dae7f603")
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 an instance of its own class, ExperienceReplay: the run constructed the object and did not call it, so no result was computed. 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
import torch.nn as nn

torch.manual_seed(0)

# Create a simple model that mimics the interface used in get_batch
class SimpleModel(nn.Module):
    def __init__(self, input_dim=4, num_actions=3):
        super(SimpleModel, self).__init__()
        self.fc = nn.Linear(input_dim, num_actions)
        self.output_shape = (None, num_actions)
    
    def predict(self, state):
        # Expects state as (1, input_dim) or (input_dim,)
        if len(state.shape) == 1:
            state = state.reshape(1, -1)
        state_tensor = torch.FloatTensor(state)
        with torch.no_grad():
            output = self.fc(state_tensor).numpy()
        return output

# Build models
input_dim = 4
num_actions = 3
model = SimpleModel(input_dim=input_dim, num_actions=num_actions)
target_model = SimpleModel(input_dim=input_dim, num_actions=num_actions)

# Create an ExperienceReplay instance and populate memory
experience_replay = None

def setup_experience_replay():
    global experience_replay
    replay = ExperienceReplay(enable_double=True, max_memory=100, discount=0.9)
    
    # Populate memory with sample experiences
    # Each memory entry is [states, game_over] where states = (state_t, action_t, reward_t, state_tp1)
    for i in range(10):
        state_t = np.random.randn(1, input_dim).astype(np.float32)
        action_t = np.random.randint(0, num_actions)
        reward_t = np.random.randn()
        state_tp1 = np.random.randn(1, input_dim).astype(np.float32)
        game_over = i % 3 == 0
        
        states = (state_t, action_t, reward_t, state_tp1)
        replay.remember(states, game_over)
    
    experience_replay = replay

class ExperienceReplay(object):

    def __init__(self, enable_double, max_memory=100, discount=0.9):
        self.max_memory = max_memory
        self.memory = list()
        self.discount = discount
        self.enable_double = enable_double

    def remember(self, states, game_over):
        self.memory.append([states, game_over])
        if len(self.memory) > self.max_memory:
            del self.memory[0]

    def get_batch(self, model, target_model, batch_size=10):
        len_memory = len(self.memory)
        num_actions = target_model.output_shape[-1]
        env_dim = self.memory[0][0][0].shape[1]
        inputs = np.zeros((min(len_memory, batch_size), env_dim))
        targets = np.zeros((inputs.shape[0], num_actions))
        for i, idx in enumerate(np.random.randint(0, len_memory, size=inputs.shape[0])):
            state_t, action_t, reward_t, state_tp1 = self.memory[idx][0]
            game_over = self.memory[idx][1]
            inputs[i:i + 1] = state_t
            targets[i] = target_model.predict(state_t)[0]
            if self.enable_double:
                a = np.argmax(model.predict(state_tp1)[0])
                Q_sa = target_model.predict(state_tp1)[0][a]
            else:
                Q_sa = np.max(target_model.predict(state_tp1)[0])
            if game_over:
                targets[i, action_t] = reward_t
            else:
                targets[i, action_t] = reward_t + self.discount * Q_sa
        return (inputs, targets)

setup_experience_replay()

ARGS = {
    'enable_double': True,
    'max_memory': 100,
    'discount': 0.9
}
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 ExperienceReplay — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ExperienceReplay 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
ExperienceReplay Ran
ran on a synthesized input
JonasRSV/DQNTensorflow/dqn.py
pointer only (licence: NONE) · get_code("96164b4731db1134")
How it ran

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

IModel Ran
ran on a synthesized input · constructed an object; no result was computed
TheFebrin/DeepRL-Pong/models/dqn_model.py
code served (permissive licence) · get_code("373f5c8eb72337f4")
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 an instance of its own class, IModel: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

class ConcreteModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

model = ConcreteModel()

ARGS = {}
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 IModel — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a IModel 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
LayerShapeLogger Ran
ran on a synthesized input · constructed an object; no result was computed
tensorpack/tensorpack/tensorpack/models/conv2d.py
code served (permissive licence) · get_code("ddd25e3de70197a2")
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 an instance of its own class, LayerShapeLogger: the run constructed the object and did not call it, so no result was computed. 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 collections
import logging

# Set up logging since the function uses logger.info
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# The LayerShapeLogger.__init__ takes no parameters
ARGS = {}
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 LayerShapeLogger — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a LayerShapeLogger 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
LinearActivation Ran
ran; our contract draft was wrong, not the code
proroklab/popgym/popgym/baselines/models/s4d.py
code served (permissive licence) · get_code("400c752a0d8d06f7")
How it ran

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

import torch
import torch.nn as nn
from functools import partial

torch.manual_seed(0)

ARGS = {
    'd_input': 4,
    'd_output': 3,
    'bias': True,
    'transposed': False,
    'activation': 'relu',
    'activate': True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Linear_QNet Ran
ran on a synthesized input
sourenaKhanzadeh/snakeAi/model.py
code served (permissive licence) · get_code("6734b023c48264d1")
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 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F
import os

class Linear_QNet(nn.Module):
    """
    Linear_QNet nn.Module class
    Model to use
    """

    def __init__(self, input_size, hidden_size, output_size):
        """
        (Linear_QNet, int, int, int) -> None
        input_size: size of the game states
        hidden_size: one layer network hidden layer size
        output_size: output size of the NN which is the number of snakes action
        """
        super().__init__()
        self.linear1 = nn.Linear(input_size, hidden_size)
        self.linear2 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        """
        (Linear_QNet, *input) -> *output
        override forward function
        add relu activation
        """
        x = F.relu(self.linear1(x))
        x = self.linear2(x)
        return x

    def save(self, file_name='model.pth'):
        """
        (Linear_QNet, str) -> None
        file_name: path of the save state files
        save the model state to a file_name
        """
        model_folder_path = './model'
        if not os.path.exists(model_folder_path):
            os.makedirs(model_folder_path)
        file_name = os.path.join(model_folder_path, file_name)
        torch.save(self.state_dict(), file_name)


INIT_ARGS = {
    'input_size': 4,
    'hidden_size': 8,
    'output_size': 3,
}

ARGS = {
    'x': torch.randn(2, 4),
}

if __name__ == '__main__':
    model = Linear_QNet(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
MLPNetwork Ran
ran on a synthesized input · constructed an object; no result was computed
chandar-lab/RLHive/hive/agents/qnets/atari/nature_atari_dqn.py
code served (permissive licence) · get_code("7af2befd6fd71b28")
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 an instance of its own class, MLPNetwork: the run constructed the object and did not call it, so no result was computed. 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
import numpy as np
import math
from functools import partial

torch.manual_seed(0)

# Construct arguments for MLPNetwork
ARGS = {
    "in_dim": (4, 5),  # Tuple representing input shape
    "hidden_units": [8, 16],  # List of hidden units for each layer
    "noisy": False,  # Use regular Linear layers
    "std_init": 0.5,  # Standard deviation initialization
}
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 MLPNetwork — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MLPNetwork 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 Ran
ran on a synthesized input · constructed an object; no result was computed
TheFebrin/DeepRL-Pong/models/dqn_model.py
code served (permissive licence) · get_code("2e7175149cc42e4e")
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 an instance of its own class, Model: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

class Model(nn.Module):
    def __init__(self, in_channels=4, out_dim=3):
        super(Model, self).__init__()
        self.conv_layers = nn.Sequential(
            nn.Conv2d(in_channels=in_channels, out_channels=16, kernel_size=(8, 8), stride=4),
            nn.ReLU(),
            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=(4, 4), stride=2),
            nn.ReLU()
        )
        self.dense_layers = nn.Sequential(
            nn.Linear(2592, 256),
            nn.ReLU(),
            nn.Linear(256, out_dim)
        )

    def forward(self, x: torch.tensor):
        x = self.conv_layers(x)
        x = torch.flatten(x, 1)
        x = self.dense_layers(x)
        return x

    def _preprocess_array(self, device: str, x) -> torch.tensor:
        x = torch.tensor(x, dtype=torch.float32) / 255.0
        if len(x.shape) == 3:
            x = x.permute(2, 0, 1)
            x = x.view(1, *x.shape)
        elif len(x.shape) == 4:
            x = x.permute(0, 3, 1, 2)
        else:
            raise ValueError(f'Wrong number of shapes: {x.shape}')
        return x.to(device)

    def forward_np_array(self, x: np.ndarray, device: str) -> torch.tensor:
        return self.forward(x=self._preprocess_array(device=device, x=x))


ARGS = {
    'in_channels': 4,
    'out_dim': 3,
}
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 Model — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Model 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 Ran
ran on a synthesized input
labmlai/annotated_deep_learning_paper_implementations/labml_nn/rl/dqn/model.py
code served (permissive licence) · get_code("0387692d5cb08179")
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 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 torch
from torch import nn

class Model(nn.Module):
    """
    ## Dueling Network ⚔️ Model for $Q$ Values

    We are using a [dueling network](https://arxiv.org/abs/1511.06581)
     to calculate Q-values.
    Intuition behind dueling network architecture is that in most states
     the action doesn't matter,
    and in some states the action is significant. Dueling network allows
     this to be represented very well.

    \x08egin{align}
        Q^\\pi(s,a) &= V^\\pi(s) + A^\\pi(s, a)
        \\
        \\mathop{\\mathbb{E}}_{a \\sim \\pi(s)}
         \\Big[
          A^\\pi(s, a)
         \\Big]
        &= 0
    \\end{align}

    So we create two networks for $V$ and $A$ and get $Q$ from them.
    $$
        Q(s, a) = V(s) +
        \\Big(
            A(s, a) - \x0crac{1}{|\\mathcal{A}|} \\sum_{a' \\in \\mathcal{A}} A(s, a')
        \\Big)
    $$
    We share the initial layers of the $V$ and $A$ networks.
    """

    def __init__(self):
        super().__init__()
        self.conv = nn.Sequential(nn.Conv2d(in_channels=4, out_channels=32, kernel_size=8, stride=4), nn.ReLU(), nn.Conv2d(in_channels=32, out_channels=64, kernel_size=4, stride=2), nn.ReLU(), nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1), nn.ReLU())
        self.lin = nn.Linear(in_features=7 * 7 * 64, out_features=512)
        self.activation = nn.ReLU()
        self.state_value = nn.Sequential(nn.Linear(in_features=512, out_features=256), nn.ReLU(), nn.Linear(in_features=256, out_features=1))
        self.action_value = nn.Sequential(nn.Linear(in_features=512, out_features=256), nn.ReLU(), nn.Linear(in_features=256, out_features=4))

    def forward(self, obs: torch.Tensor):
        h = self.conv(obs)
        h = h.reshape((-1, 7 * 7 * 64))
        h = self.activation(self.lin(h))
        action_value = self.action_value(h)
        state_value = self.state_value(h)
        action_score_centered = action_value - action_value.mean(dim=-1, keepdim=True)
        q = state_value + action_score_centered
        return q


INIT_ARGS = {}

ARGS = {
    'obs': torch.randn(2, 4, 84, 84)
}

if __name__ == '__main__':
    model = Model(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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 — 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)
NatureCnnBackboneNet Ran
ran on a synthesized input
michaelnny/deep_rl_zoo/deep_rl_zoo/networks/value.py
code served (permissive licence) · get_code("c448520babac98f1")
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 2, dtype family float, shape (2, 3136) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn
from typing import Tuple
import math

def calc_conv2d_output(h_w: Tuple, kernel_size: int=1, stride: int=1, pad: int=0, dilation: int=1) -> Tuple[int, int]:
    """Takes a tuple of (h,w) and returns a tuple of (h,w)"""
    if not isinstance(kernel_size, Tuple):
        kernel_size = (kernel_size, kernel_size)
    h = math.floor((h_w[0] + 2 * pad - dilation * (kernel_size[0] - 1) - 1) / stride + 1)
    w = math.floor((h_w[1] + 2 * pad - dilation * (kernel_size[1] - 1) - 1) / stride + 1)
    return (h, w)

class NatureCnnBackboneNet(nn.Module):
    """DQN Nature paper conv2d layers backbone, returns feature representation vector."""

    def __init__(self, state_dim: tuple) -> None:
        super().__init__()
        c, h, w = state_dim
        h, w = calc_conv2d_output((h, w), 8, 4)
        h, w = calc_conv2d_output((h, w), 4, 2)
        h, w = calc_conv2d_output((h, w), 3, 1)
        self.out_features = 64 * h * w
        self.net = nn.Sequential(nn.Conv2d(in_channels=c, out_channels=32, kernel_size=8, stride=4), nn.ReLU(), nn.Conv2d(in_channels=32, out_channels=64, kernel_size=4, stride=2), nn.ReLU(), nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1), nn.ReLU(), nn.Flatten())

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """Given raw state images, returns feature representation vector"""
        return self.net(x)


INIT_ARGS = {
    "state_dim": (3, 84, 84)
}

ARGS = {
    "x": torch.randn(2, 3, 84, 84)
}

if __name__ == "__main__":
    model = NatureCnnBackboneNet(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Output features: {model.out_features}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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, 3136) — shape (2, 3136) 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Net Ran
ran on a synthesized input · constructed an object; no result was computed
OscarHuangWind/Preference-Guided-DQN-Atari/Network.py
code served (permissive licence) · get_code("93b98bd6ec8a54eb")
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 an instance of its own class, Net: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import numpy as np
import random

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

# Define ARGS with all parameters for Net.__init__
ARGS = {
    'height': 84,
    'width': 84,
    'channel': 3,
    'num_outputs': 4,
    'dueling': False,
    'preference': False,
    'seed': 42
}
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 Net — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Net 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
NoisyLinear Ran
ran on a synthesized input · constructed an object; no result was computed
chandar-lab/RLHive/hive/agents/qnets/atari/nature_atari_dqn.py
code served (permissive licence) · get_code("e2d32d93aef8dd96")
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 an instance of its own class, NoisyLinear: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn
import math

torch.manual_seed(0)

ARGS = {
    "in_dim": 4,
    "out_dim": 3,
    "std_init": 0.5
}
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 NoisyLinear — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a NoisyLinear 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
QNetwork Ran
ran on a synthesized input · constructed an object; no result was computed
Linging/Traffic-Signal-Control/Agent/networks.py
pointer only (licence: NONE) · get_code("391471b2e6f9888c")
How it ran

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

RLNetwork Ran
ran on a synthesized input · constructed an object; no result was computed
komejisatori/ReinforcementCar/model/network.py
pointer only (licence: NONE) · get_code("770e704a180ff720")
How it ran

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

ResidualBlock Ran
ran on a synthesized input · constructed an object; no result was computed
Sheepsody/Batched-Impala-PyTorch/src/networks/ActorCritic.py
pointer only (licence: NONE) · get_code("cb2515fde4e1a0e0")
How it ran

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

ShallowConv Ran
ran on a synthesized input · constructed an object; no result was computed
Sheepsody/Batched-Impala-PyTorch/src/networks/ActorCritic.py
pointer only (licence: NONE) · get_code("3298a4358c400287")
How it ran

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

Training Ran
ran on a synthesized input · constructed an object; no result was computed
BH4/Deep-Reinforcement-Learning/Training/qlearn.py
code served (permissive licence) · get_code("54e74edb75cc6f83")
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 an instance of its own class, Training: the run constructed the object and did not call it, so no result was computed. 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 json
from unittest.mock import Mock, MagicMock
from keras.models import Sequential
from keras.layers import Dense

# Create a minimal Keras model
model = Sequential([
    Dense(8, input_dim=4, activation='relu'),
    Dense(3, activation='linear')
])
model.compile(optimizer='sgd', loss='mse')

# Create a mock environment
class MockEnv:
    def __init__(self):
        self.state = np.random.rand(1, 4).astype(np.float32)
        self.score = 0
        self.step_count = 0
    
    def reset(self):
        self.state = np.random.rand(1, 4).astype(np.float32)
        self.step_count = 0
    
    def reset_score(self):
        self.score = 0
    
    def observe(self):
        return self.state
    
    def act(self, action):
        self.step_count += 1
        next_state = np.random.rand(1, 4).astype(np.float32)
        reward = 1.0
        game_over = self.step_count >= 3
        self.state = next_state
        return next_state, reward, game_over
    
    def statistics(self):
        return f"Score: {self.score}"

env = MockEnv()

ARGS = {
    'env': env,
    'model': model,
    'name': 'test_model',
    'max_memory': 50,
    'batch_size': 10,
    'target_model_update': 5,
    'enable_double': False,
    'enable_dueling': False,
    'dueling_type': 'avg'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
keras, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Training — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Training 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
VariableHolder Ran
ran on a synthesized input · constructed an object; no result was computed
tensorpack/tensorpack/tensorpack/models/conv2d.py
code served (permissive licence) · get_code("a1061c9f352373b7")
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 an instance of its own class, VariableHolder: the run constructed the object and did not call it, so no result was computed. 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 six

torch.manual_seed(0)

# The VariableHolder.__init__ accepts **kwargs where each kwarg is {name: variable}
# Looking at the code:
# - It iterates through kwargs using six.iteritems()
# - Each key-value pair is added via _add_variable()
# - Variables can be anything (tensors, numbers, objects, etc.)
# - The all() method returns a list of all stored variables

# Create some sample variables to pass as kwargs
var1 = torch.randn(2, 4)
var2 = torch.randn(3, 5)
var3 = 42
var4 = "test_string"

ARGS = {
    'kwargs': {
        'weight': var1,
        'bias': var2,
        'count': var3,
        'name': var4
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
six, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type VariableHolder — the run constructed an instance of its own class and did not call it; no shape 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
_output_size_conv2d Ran
ran; our contract draft was wrong, not the code
Sheepsody/Batched-Impala-PyTorch/src/networks/ActorCritic.py
pointer only (licence: NONE) · get_code("18e2a7b2917f4571")
How it ran

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

base_name Ran
ran; our contract draft was wrong, not the code
parilo/rl-server/tf_rl/conv_model.py
pointer only (licence: NONE) · get_code("bff3b19f646bee04")
How it ran

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

base_name2 Ran
ran; our contract draft was wrong, not the code
parilo/rl-server/tf_rl/conv_model.py
pointer only (licence: NONE) · get_code("dca827af2639f99d")
How it ran

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

build_q_network Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
eddynelson/dqn/dqn/networks/dueling_network.py
code served (permissive licence) · get_code("d09a6a1f1807cb36")
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 Functional. 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 tensorflow as tf
from tensorflow.keras import Model
from tensorflow.keras import layers
from tensorflow.keras.initializers import VarianceScaling

# Define arguments for build_q_network
ARGS = {
    "n_actions": 18,
    "input_shape": (84, 84),
    "history_length": 4
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Functional — a Functional output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Functional 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
calc_conv2d_output Ran
ran; our contract draft was wrong, not the code
michaelnny/deep_rl_zoo/deep_rl_zoo/networks/value.py
code served (permissive licence) · get_code("9c004a3c7f80a048")
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 tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import math
from typing import Tuple

torch.manual_seed(0)

# The function takes h_w (a tuple of height and width), kernel_size, stride, pad, and dilation
# and returns output spatial dimensions after a conv2d operation

# Create valid arguments
h_w = (28, 32)  # input height and width (distinct sizes for clarity)
kernel_size = 3
stride = 1
pad = 1
dilation = 1

ARGS = {
    "h_w": h_w,
    "kernel_size": kernel_size,
    "stride": stride,
    "pad": pad,
    "dilation": dilation
}
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 tuple, ndim 1, dtype family int — 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
calculate_output_dim Ran
ran, honoured the contract we drafted
chandar-lab/RLHive/hive/agents/qnets/atari/nature_atari_dqn.py
code served (permissive licence) · get_code("6ec20a43d727c364")
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 Size. 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 simple network that accepts the input and produces an output
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

net = SimpleNet()

input_shape = 4

ARGS = {
    "net": net,
    "input_shape": input_shape,
}
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 Size — a Size output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Size output the recorded ndim 1 and dtype family int describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_to_tflayer_args Ran
ran; our contract draft was wrong, not the code
tensorpack/tensorpack/tensorpack/models/conv2d.py
code served (permissive licence) · get_code("58a16fa9e75bc087")
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
import functools
import six

torch.manual_seed(0)

# The decorator function that we need to test
def get_data_format(data_format, keras_mode=True):
    if keras_mode:
        dic = {'NCHW': 'channels_first', 'NHWC': 'channels_last'}
    else:
        dic = {'channels_first': 'NCHW', 'channels_last': 'NHWC'}
    ret = dic.get(data_format, data_format)
    if ret not in dic.values():
        raise ValueError('Unknown data_format: {}'.format(data_format))
    return ret

def map_common_tfargs(kwargs):
    df = kwargs.pop('data_format', None)
    if df is not None:
        df = get_data_format(df, keras_mode=True)
        kwargs['data_format'] = df
    old_nl = kwargs.pop('nl', None)
    if old_nl is not None:
        kwargs['activation'] = lambda x, name=None: old_nl(x, name=name)
    if 'W_init' in kwargs:
        kwargs['kernel_initializer'] = kwargs.pop('W_init')
    if 'b_init' in kwargs:
        kwargs['bias_initializer'] = kwargs.pop('b_init')
    return kwargs

def convert_to_tflayer_args(args_names, name_mapping):
    """
    After applying this decorator:
    1. data_format becomes tf.layers style
    2. nl becomes activation
    3. initializers are renamed
    4. positional args are transformed to corresponding kwargs, according to args_names
    5. kwargs are mapped to tf.layers names if needed, by name_mapping
    """

    def decorator(func):

        @functools.wraps(func)
        def decorated_func(inputs, *args, **kwargs):
            kwargs = map_common_tfargs(kwargs)
            posarg_dic = {}
            assert len(args) <= len(args_names), 'Please use kwargs instead of positional args to call this model, except for the following arguments: {}'.format(', '.join(args_names))
            for pos_arg, name in zip(args, args_names):
                posarg_dic[name] = pos_arg
            ret = {}
            for name, arg in six.iteritems(kwargs):
                newname = name_mapping.get(name, None)
                if newname is not None:
                    assert newname not in kwargs, 'Argument {} and {} conflicts!'.format(name, newname)
                else:
                    newname = name
                ret[newname] = arg
            ret.update(posarg_dic)
            return func(inputs, **ret)
        return decorated_func
    return decorator


# Create sample test function
@convert_to_tflayer_args(
    args_names=['filters', 'kernel_size'],
    name_mapping={'old_param': 'new_param', 'deprecated': 'modern'}
)
def sample_layer(inputs, filters=32, kernel_size=3, **kwargs):
    return inputs, filters, kernel_size, kwargs


# Define ARGS - mapping every parameter of convert_to_tflayer_args
ARGS = {
    'args_names': ['filters', 'kernel_size', 'padding'],
    'name_mapping': {
        'old_name': 'new_name',
        'legacy_param': 'current_param',
        'data_format': 'data_format',
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
six, 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
customBoard Ran
ran on a synthesized input · constructed an object; no result was computed
invictos/InsacarDQN/agent/agent.py
pointer only (licence: GPL-3.0) · get_code("b93a2d0046d7cf64")
How it ran

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

dplr Ran
ran; our contract draft was wrong, not the code
proroklab/popgym/popgym/baselines/models/s4d.py
code served (permissive licence) · get_code("391c3adc43a9fb2d")
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 math

torch.manual_seed(0)

ARGS = {
    'scaling': 'legs',
    'N': 4,
    'rank': 1,
    'H': 2,
    'dtype': torch.float,
    'real_scale': 1.0,
    'imag_scale': 1.0,
    'random_real': False,
    'random_imag': False,
    'normalize': False,
    'diagonal': True,
    'random_B': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, numpy, opt_einsum, 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
flatten Ran
ran; our contract draft was wrong, not the code
alfredvc/paac/networks.py
pointer only (licence: NOASSERTION) · get_code("143311d10e7d046c")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, alfredvc/paac (NOASSERTION). 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_data_format Ran
ran; our contract draft was wrong, not the code
tensorpack/tensorpack/tensorpack/models/conv2d.py
code served (permissive licence) · get_code("e57b423feb455f31")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

# The function takes two parameters:
# 1. data_format: a string that should be one of 'NCHW', 'NHWC', 'channels_first', or 'channels_last'
# 2. keras_mode: a boolean that determines which dictionary mapping to use

# Let's test with keras_mode=True and a valid NCHW format
ARGS = {
    'data_format': 'NCHW',
    'keras_mode': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_tf_version_tuple Ran
ran on a synthesized input
tensorpack/tensorpack/tensorpack/models/conv2d.py
code served (permissive licence) · get_code("436e0ec3f2b87eea")
How it ran

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

def get_tf_version_tuple():
    """
    Return TensorFlow version as a 2-element tuple (for comparison).
    """
    return tuple(map(int, tf.__version__.split('.')[:2]))

ARGS = {}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — 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 int — 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
huber_loss Ran
ran, honoured the contract we drafted
KavindaKottege/DeepQ-Pong/DeepQ-Pong.py
pointer only (licence: NONE) · get_code("eaf9a525f0459416")
How it ran

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

image_number Ran
ran on a synthesized input
tlohr/nfsu2-ai/CreateDataSet.py
code served (permissive licence) · get_code("1e29c6e3df986421")
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 re

def image_number(image):
    image = re.sub('^race_314_out', '', image)
    image = re.sub('.png$', '', image)
    return int(image)

ARGS = {
    'image': 'race_314_out123.png'
}
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 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
layer_register Ran
ran; our contract draft was wrong, not the code
tensorpack/tensorpack/tensorpack/models/conv2d.py
code served (permissive licence) · get_code("802a4fa23e5c7036")
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 tensorflow as tf
import six
import copy
import re
import collections
from functools import wraps

# Mock logger since it's used in the function
class MockLogger:
    def info(self, msg):
        pass
    def warn(self, msg):
        pass
    def error(self, msg):
        pass

logger = MockLogger()

# Mock tfv1 since it's used in the function
class MockVariableScope:
    def __init__(self, name):
        self.name = name
    def __enter__(self):
        return self
    def __exit__(self, *args):
        pass

class MockTFV1:
    @staticmethod
    def variable_scope(name):
        return MockVariableScope(name)

tfv1 = MockTFV1()

# Mock get_arg_scope and get_shape_str functions
def get_arg_scope():
    return collections.defaultdict(dict)

def get_shape_str(tensor):
    if isinstance(tensor, (list, tuple)):
        return str([t.shape for t in tensor])
    return str(tensor.shape)

# Now define test arguments for layer_register
ARGS = {
    'log_shape': False,
    'use_scope': True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
six, tensorflow — 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
map_common_tfargs Ran
ran; our contract draft was wrong, not the code
tensorpack/tensorpack/tensorpack/models/conv2d.py
code served (permissive licence) · get_code("ac7dc76edd237aa9")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

# Test case 1: kwargs with data_format in NCHW format
kwargs_1 = {
    'data_format': 'NCHW',
    'nl': lambda x, name=None: x * 2,
    'W_init': 'glorot_uniform',
    'b_init': 'zeros'
}

# Test case 2: kwargs with data_format in channels_first format
kwargs_2 = {
    'data_format': 'channels_first',
}

# Test case 3: kwargs with minimal arguments
kwargs_3 = {}

# Test case 4: kwargs with only nl parameter
kwargs_4 = {
    'nl': lambda x, name=None: torch.relu(x)
}

# Test case 5: kwargs with all parameters
kwargs_5 = {
    'data_format': 'NHWC',
    'nl': lambda x, name=None: x + 1,
    'W_init': 'he_normal',
    'b_init': 'ones'
}

ARGS = {
    'kwargs': kwargs_1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
map_dqn_var Ran
ran; our contract draft was wrong, not the code
eublefar/dqn/dqn.py
pointer only (licence: NONE) · get_code("1afb1d67cec9b38b")
How it ran

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

module Ran
ran on a synthesized input
epignatelli/human-level-control-through-deep-reinforcement-learning/dqn/base.py
code served (permissive licence) · get_code("a8cd6ded600d9813")
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 jax
import jax.numpy as jnp
from typing import Tuple, Any

def sample_module_maker(hidden_dim: int = 8):
    """
    A simple module maker that returns init and apply functions.
    This matches the expected signature for the @module decorator.
    """
    def init(rng_key: jnp.ndarray, input_shape: Tuple[int, ...]) -> Tuple[Tuple[int, ...], dict]:
        """Initialize parameters for the module."""
        output_shape = (input_shape[0], hidden_dim)
        params = {
            'weight': jnp.ones((input_shape[-1], hidden_dim)),
            'bias': jnp.zeros(hidden_dim)
        }
        return output_shape, params
    
    def apply(params: dict, x: jnp.ndarray) -> jnp.ndarray:
        """Apply the module to input."""
        return jnp.dot(x, params['weight']) + params['bias']
    
    return init, apply

ARGS = {
    'module_maker': sample_module_maker
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
movingaverage Ran
ran on a synthesized input
borhanreo/Obstacle-Avoid-Car/plotting.py
code served (permissive licence) · get_code("215e80576955e5a8")
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 (10,) 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 simple 1D array of data points for the moving average
y = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])

# Define window size for the moving average
window_size = 3

ARGS = {
    'y': y,
    'window_size': window_size
}
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 (10,) — shape (10,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
neural_net Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
vsquareg/RL_ERA/nn.py
code served (permissive licence) · get_code("634d6466b3771df7")
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 Sequential. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Define arguments for neural_net function
num_sensors = 8
params = [16, 32, 64]  # Three hidden layer sizes
load = ''  # Empty string means don't load weights

ARGS = {
    'num_sensors': num_sensors,
    'params': params,
    'load': load
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 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
nplr Ran
ran; our contract draft was wrong, not the code
proroklab/popgym/popgym/baselines/models/s4d.py
code served (permissive licence) · get_code("08037869b6206d12")
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

torch.manual_seed(0)

ARGS = {
    'measure': 'legs',
    'N': 4,
    'rank': 1,
    'dtype': torch.float,
    'diagonalize_precision': True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, opt_einsum, 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
params_to_filename Ran
ran on a synthesized input
borhanreo/Obstacle-Avoid-Car/learning.py
code served (permissive licence) · get_code("3d3d55b5d8bd5963")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

# The function accesses params['nn'][0], params['nn'][1], params['batchSize'], and params['buffer']
# It converts them all to strings, so they can be any type that has a __str__ method

ARGS = {
    'params': {
        'nn': [64, 128],
        'batchSize': 32,
        'buffer': 1000
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
power Ran
ran; our contract draft was wrong, not the code
proroklab/popgym/popgym/baselines/models/s4d.py
code served (permissive licence) · get_code("14bcfdbb8473e4b3")
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
from einops import rearrange, repeat

torch.manual_seed(0)

# Construct arguments for the power function
# L: int - the exponent
# A: torch.Tensor of shape (..., N, N) - the matrix to raise to power L
# v: torch.Tensor of shape (..., N, L) or None - optional vector

L = 8  # exponent value

# Create a small square matrix A with shape (4, 4)
A = torch.randn(4, 4)

# Create v with shape (4, 8) to match L dimension
# The function expects v to have shape (..., N, L) where N matches A's dimension
v = torch.randn(4, 8)

ARGS = {
    'L': L,
    'A': A,
    'v': v
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
process_minibatch Ran
ran on a synthesized input
borhanreo/Obstacle-Avoid-Car/learning.py
code served (permissive licence) · get_code("5448b18f64386fdb")
How it ran

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

import numpy as np
import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a simple model that implements predict method
class SimpleQModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(3, 3)
    
    def predict(self, state, batch_size=1):
        """Predict Q-values for a given state."""
        if isinstance(state, np.ndarray):
            state = torch.from_numpy(state).float()
        if state.dim() == 1:
            state = state.unsqueeze(0)
        with torch.no_grad():
            output = self.fc(state)
        return output.numpy()

model = SimpleQModel()

# Create minibatch: list of (old_state, action, reward, new_state) tuples
minibatch = [
    (
        np.array([0.1, 0.2, 0.3]),           # old_state_m
        1,                                     # action_m (0-2)
        5.0,                                   # reward_m
        np.array([0.4, 0.5, 0.6])            # new_state_m
    ),
    (
        np.array([0.2, 0.3, 0.4]),           # old_state_m
        2,                                     # action_m (0-2)
        10.0,                                  # reward_m
        np.array([0.5, 0.6, 0.7])            # new_state_m
    )
]

ARGS = {
    "minibatch": minibatch,
    "model": model
}
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 tuple, ndim 3, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
process_minibatch2 Ran
ran on a synthesized input
borhanreo/Obstacle-Avoid-Car/learning.py
code served (permissive licence) · get_code("316b3c2ef7ed0d5e")
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 numpy as np
import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a simple model that implements predict method
class SimpleQNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(3, 8)
        self.fc2 = nn.Linear(8, 4)
    
    def forward(self, x):
        x = torch.relu(self.fc1(torch.tensor(x, dtype=torch.float32)))
        return self.fc2(x)
    
    def predict(self, x, batch_size):
        with torch.no_grad():
            x_tensor = torch.tensor(x, dtype=torch.float32)
            output = self.forward(x_tensor)
            return output.numpy()

# Create model instance
model = SimpleQNetwork()

# Create minibatch: list of (old_state, action, reward, new_state) tuples
# old_state: shape (3,)
# action: scalar
# reward: scalar
# new_state: shape (3,)
minibatch = [
    (np.array([1.0, 2.0, 3.0]), 0, 10.0, np.array([1.5, 2.5, 3.5])),
    (np.array([4.0, 5.0, 6.0]), 1, -500, np.array([4.5, 5.5, 6.5])),
]

ARGS = {
    "minibatch": minibatch,
    "model": model
}
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 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
rank_correction Ran
ran, honoured the contract we drafted
proroklab/popgym/popgym/baselines/models/s4d.py
code served (permissive licence) · get_code("67e350096b3030fb")
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 (1, 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)

ARGS = {
    'measure': 'legs',
    'N': 4,
    'rank': 1,
    'dtype': torch.float,
}
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 (1, 4) — shape (1, 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
readable_output Ran
ran on a synthesized input
borhanreo/Obstacle-Avoid-Car/plotting.py
code served (permissive licence) · get_code("8987d3556f2dbdbe")
How it ran

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

import torch

torch.manual_seed(0)

ARGS = {
    'filename': 'learn_data-metric1-metric2-optimizer-epoch.txt'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
sample_memories Ran
ran on a synthesized input
jonaths/tf-dqn/tiny_dqn.py
code served (permissive licence) · get_code("df21990110979f81")
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 numpy as np
from collections import deque

# Set up the replay memory with some sample memories
replay_memory = deque([], maxlen=20000)

# Each memory is a tuple of (state, action, reward, next_state, done)
# state: shape (4,) - observation
# action: scalar - action taken
# reward: scalar - reward received
# next_state: shape (4,) - next observation
# done: scalar - whether episode ended

np.random.seed(0)

# Populate replay memory with sample transitions
for i in range(100):
    state = np.random.randn(4).astype(np.float32)
    action = np.random.randint(0, 3)
    reward = np.random.randn()
    next_state = np.random.randn(4).astype(np.float32)
    done = np.random.randint(0, 2)
    
    memory = (state, action, reward, next_state, done)
    replay_memory.append(memory)

ARGS = {
    'batch_size': 50
}
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 — 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

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

Also present in other papers' code

Of 117 samples lifted from this paper's linked repositories, 117 carry a function identity and 0 do not. Of the 117 distinct functions with an identity, 21 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 21 later) and 96 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
LinearActivation
brick of this paper's assembly: helper
8 other papers
8 later
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
2111.00396 (2021-11)
Efficiently Modeling Long Sequences with Structured State Spaces
2211.11176 (2022-11)
Modeling Multivariate Biosignals With Graph Neural Networks and Structured State Space Models
and 5 more not named here
power
brick of this paper's assembly: helper
4 other papers
4 later
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
2111.00396 (2021-11)
Efficiently Modeling Long Sequences with Structured State Spaces
2204.01692 (2022-04)
Long Movie Clip Classification with State-Space Video Models
and 1 more not named here
combination
brick of this paper's assembly: helper
3 other papers
3 later
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
2212.14052 (2022-12)
Hungry Hungry Hippos: Towards Language Modeling with State Space Models
2411.04165 (2024-11)
Bio-xLSTM: Generative modeling, representation and in-context learning of biological and chemical sequences
ActionStateModel
brick of this paper's assembly: entry
1 other paper
1 later
1509.06461 (2015-09)
Deep Reinforcement Learning with Double Q-learning
ExperienceReplay
brick of this paper's assembly: sampler
1 other paper
1 later
1509.02971 (2015-09)
Continuous control with deep reinforcement learning
LayerShapeLogger
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
Net
brick of this paper's assembly: entry
1 other paper
1 later
1509.06461 (2015-09)
Deep Reinforcement Learning with Double Q-learning
OptimModule
brick of this paper's assembly: helper
1 other paper
1 later
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
VariableHolder
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
_register
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
convert_to_tflayer_args
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
dplr
brick of this paper's assembly: helper
1 other paper
1 later
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
get_data_format
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
get_tf_version_tuple
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
layer_register
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
map_common_tfargs
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
nplr
brick of this paper's assembly: helper
1 other paper
1 later
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
rank_correction
brick of this paper's assembly: helper
1 other paper
1 later
2009.09761 (2020-09)
DiffWave: A Versatile Diffusion Model for Audio Synthesis
rename_get_variable
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
shape2d
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
1511.06434 (2015-11)
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks

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

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

Repositories linked to this paper

More are linked than shown here.

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

Abstract

We present the first deep learning model to successfully learn control policies directly from high-dimensional sensory input using reinforcement learning. The model is a convolutional neural network, trained with a variant of Q-learning, whose input is raw pixels and whose output is a value function estimating future rewards. We apply our method to seven Atari 2600 games from the Arcade Learning Environment, with no adjustment of the architecture or learning algorithm. We find that it outperforms all previous approaches on six of the games and surpasses a human expert on three of them.

For agents

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

get_harvested_code_for_paper("1312.5602")
get_code_for_paper("1312.5602")
have("1312.5602")

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

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

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

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

Connect an agent — have() is free.