SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2110.06169 · 2021

Offline Reinforcement Learning with Implicit Q-Learning

Sergey Levine, Ashvin Nair, Ilya Kostrikov

arXiv · PDF · Open in the Atlas

Code that ran

45 of 58 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (23 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 36 have no contract verdict; 9 failures of our instrument; 13 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/2110.06169.json · badge: /api/ran/2110.06169.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
dasgringuen/assetto_corsa_gym community (classifier label)
classifier basis not recorded on the link
14 ran · 3 no recorded run
typoverflow/OfflineRL-Lib community
Papers with Code archive
7 ran · 5 no recorded run
orrivlin/implicit-q-learning community
Papers with Code archive
6 ran · 1 no recorded run
Manchery/iql-pytorch community
Papers with Code archive
6 ran · 0 no recorded run
BY571/Implicit-Q-Learning community
Papers with Code archive
4 ran · 0 no recorded run
yihaosun1124/OfflineRL-Kit community
Papers with Code archive
2 ran · 0 no recorded run
linhlpv/Offline-and-OfflineOnline-RL community
Papers with Code archive
2 ran · 0 no recorded run
runamu/compositional-conservatism community
Papers with Code archive
1 ran · 1 no recorded run
gwthomas/iql-pytorch community
Papers with Code archive
1 ran · 1 no recorded run
corl-team/CORL community
Papers with Code archive
1 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
zzmtsvv/rl_task community
Papers with Code archive
0 ran · 2 no recorded run
FunctionStatusWhere it lives
Actor Ran
ran on a synthesized input · constructed an object; no result was computed
orrivlin/implicit-q-learning/IQL.py
pointer only (licence: NONE) · get_code("9a453c413229c3e8")
How it ran

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

Actor Ran
ran on a synthesized input · constructed an object; no result was computed
Manchery/iql-pytorch/IQL.py
pointer only (licence: NONE) · get_code("966c8f4b02ba3120")
How it ran

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

Actor Ran
ran on a synthesized input · constructed an object; no result was computed
BY571/Implicit-Q-Learning/agent.py
pointer only (licence: NONE) · get_code("b6a1eedb944158c8")
How it ran

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

BasePolicy Ran
ran on a synthesized input · constructed an object; no result was computed
yihaosun1124/OfflineRL-Kit/offlinerlkit/policy/model_free/iql.py
code served (permissive licence) · get_code("bc6ec59a73ed3500")
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, BasePolicy: 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
from typing import Dict

torch.manual_seed(0)

# BasePolicy is a base class with abstract methods, so we need to instantiate it
# or create a concrete subclass. Since the function signature shows it's meant to be
# subclassed, we'll create a minimal concrete implementation.

class ConcretePolicy(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.fc = nn.Linear(4, 2)
    
    def train(self, mode=True):
        super().train(mode)
    
    def eval(self):
        super().eval()
    
    def select_action(self, obs: np.ndarray, deterministic: bool = False) -> np.ndarray:
        # Convert obs to tensor, pass through network, return as numpy
        obs_tensor = torch.from_numpy(obs).float().unsqueeze(0)
        with torch.no_grad():
            action = self.fc(obs_tensor)
        return action.numpy()
    
    def learn(self, batch: Dict) -> Dict[str, float]:
        # Simple implementation that returns a loss dict
        if 'obs' in batch:
            obs = torch.from_numpy(batch['obs']).float()
            loss = self.fc(obs).mean()
            return {'loss': loss.item()}
        return {'loss': 0.0}

# Create instance and batch data
policy = ConcretePolicy()

# Create a sample batch with observation data
batch = {
    'obs': np.random.randn(2, 4).astype(np.float32),
    'action': np.random.randn(2, 2).astype(np.float32),
}

# Map all parameters of BasePolicy to values
# BasePolicy.__init__ takes no parameters other than self
ARGS = {}
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 BasePolicy — 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 BasePolicy 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
BasePolicy Ran
ran on a synthesized input · constructed an object; no result was computed
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("f49a5596a23ec01c")
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, BasePolicy: 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 typing import Dict, Any

torch.manual_seed(0)

class BasePolicy(nn.Module):

    def __init__(self) -> None:
        super().__init__()

    def update(self, batch: Dict[str, Any]) -> Dict[str, Any]:
        raise NotImplementedError

    def select_action(self, obs: np.ndarray, *args, **kwargs):
        raise NotImplementedError

    def to(self, device):
        self.device = device
        super().to(device)
        return self


ARGS = {}
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 BasePolicy — 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 BasePolicy 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
Critic Ran
ran on a synthesized input · constructed an object; no result was computed
orrivlin/implicit-q-learning/IQL.py
pointer only (licence: NONE) · get_code("80a6ad9eabb2130a")
How it ran

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

Critic Ran
ran on a synthesized input · constructed an object; no result was computed
Manchery/iql-pytorch/IQL.py
pointer only (licence: NONE) · get_code("babedc4feb0bd1bc")
How it ran

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

Critic Ran
ran on a synthesized input · constructed an object; no result was computed
BY571/Implicit-Q-Learning/agent.py
pointer only (licence: NONE) · get_code("1a4179d29d5698c1")
How it ran

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

DiagGaussianActor Ran
ran on a synthesized input · constructed an object; no result was computed
orrivlin/implicit-q-learning/IQL.py
pointer only (licence: NONE) · get_code("96a8264069e38c3a")
How it ran

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

EnsembleLinear Ran
ran on a synthesized input · constructed an object; no result was computed
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("8d9ce25604e09aac")
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, EnsembleLinear: 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 math

torch.manual_seed(0)

# Define ARGS dict with all parameters for EnsembleLinear.__init__
ARGS = {
    'in_features': 4,
    'out_features': 3,
    'ensemble_size': 2,
    'share_input': True,
    'bias': True,
    'device': None,
    'dtype': None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EnsembleLinear — 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 EnsembleLinear 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
IQL Ran
ran on a synthesized input · constructed an object; no result was computed
Manchery/iql-pytorch/IQL.py
pointer only (licence: NONE) · get_code("6310a7198b14e85d")
How it ran

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

IQL Ran
ran on a synthesized input · constructed an object; no result was computed
BY571/Implicit-Q-Learning/agent.py
pointer only (licence: NONE) · get_code("c23983ba22a35975")
How it ran

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

IQLPolicy Ran
ran on a synthesized input · constructed an object; no result was computed
yihaosun1124/OfflineRL-Kit/offlinerlkit/policy/model_free/iql.py
code served (permissive licence) · get_code("d14cce65ce43e79e")
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, IQLPolicy: 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 gym
from gym import spaces

torch.manual_seed(0)

# Define small neural network modules for actor and critics
class SimpleActor(nn.Module):
    def __init__(self, obs_dim, action_dim):
        super().__init__()
        self.net = nn.Linear(obs_dim, action_dim * 2)
    
    def forward(self, obs):
        x = self.net(obs)
        mean = x[..., :x.shape[-1]//2]
        std = torch.ones_like(mean)
        return torch.distributions.Normal(mean, std)

class SimpleCriticQ(nn.Module):
    def __init__(self, obs_dim, action_dim):
        super().__init__()
        self.net = nn.Linear(obs_dim + action_dim, 1)
    
    def forward(self, obs, action):
        x = torch.cat([obs, action], dim=-1)
        return self.net(x)

class SimpleCriticV(nn.Module):
    def __init__(self, obs_dim):
        super().__init__()
        self.net = nn.Linear(obs_dim, 1)
    
    def forward(self, obs):
        return self.net(obs)

# Create small tensors and modules
obs_dim = 4
action_dim = 3
batch_size = 2

actor = SimpleActor(obs_dim, action_dim)
critic_q1 = SimpleCriticQ(obs_dim, action_dim)
critic_q2 = SimpleCriticQ(obs_dim, action_dim)
critic_v = SimpleCriticV(obs_dim)

actor_optim = torch.optim.Adam(actor.parameters(), lr=1e-3)
critic_q1_optim = torch.optim.Adam(critic_q1.parameters(), lr=1e-3)
critic_q2_optim = torch.optim.Adam(critic_q2.parameters(), lr=1e-3)
critic_v_optim = torch.optim.Adam(critic_v.parameters(), lr=1e-3)

# Create action space
action_space = spaces.Box(low=-1.0, high=1.0, shape=(action_dim,), dtype=np.float32)

ARGS = {
    'actor': actor,
    'critic_q1': critic_q1,
    'critic_q2': critic_q2,
    'critic_v': critic_v,
    'actor_optim': actor_optim,
    'critic_q1_optim': critic_q1_optim,
    'critic_q2_optim': critic_q2_optim,
    'critic_v_optim': critic_v_optim,
    'action_space': action_space,
    'tau': 0.005,
    'gamma': 0.99,
    'expectile': 0.8,
    'temperature': 0.1
}
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 IQLPolicy — 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 IQLPolicy 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
IQLPolicy Ran
ran on a synthesized input · constructed an object; no result was computed
runamu/compositional-conservatism/offlinerlkit/policy/model_free/iql.py
code served (permissive licence) · get_code("ec0dfb8aa1f8f95a")
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, IQLPolicy: 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 gym
import numpy as np
from copy import deepcopy

torch.manual_seed(0)

# Create a simple args object
class Args:
    def __init__(self):
        self.learning_rate = 0.001

args = Args()

# Create simple neural network modules
class SimpleActor(nn.Module):
    def __init__(self, obs_dim, action_dim):
        super().__init__()
        self.fc = nn.Linear(obs_dim, action_dim * 2)
        self.anchor_handler = None
    
    def forward(self, obs):
        x = self.fc(obs)
        mean = x[:, :x.shape[1]//2]
        std = torch.exp(x[:, x.shape[1]//2:])
        return torch.distributions.Normal(mean, std)

class SimpleCritic(nn.Module):
    def __init__(self, obs_dim, action_dim=None):
        super().__init__()
        input_dim = obs_dim + (action_dim if action_dim is not None else 0)
        self.fc = nn.Linear(input_dim, 1)
    
    def forward(self, obs, actions=None):
        if actions is not None:
            x = torch.cat([obs, actions], dim=-1)
        else:
            x = obs
        return self.fc(x)

# Simple anchor handler mock
class AnchorHandler:
    def toggle_on_store(self):
        pass
    
    def toggle_on_reuse(self):
        pass

obs_dim = 4
action_dim = 3

actor = SimpleActor(obs_dim, action_dim)
critic_q1 = SimpleCritic(obs_dim, action_dim)
critic_q2 = SimpleCritic(obs_dim, action_dim)
critic_v = SimpleCritic(obs_dim)

actor.anchor_handler = AnchorHandler()

# Create optimizers
actor_optim = torch.optim.Adam(actor.parameters(), lr=0.001)
critic_q1_optim = torch.optim.Adam(critic_q1.parameters(), lr=0.001)
critic_q2_optim = torch.optim.Adam(critic_q2.parameters(), lr=0.001)
critic_v_optim = torch.optim.Adam(critic_v.parameters(), lr=0.001)

# Create action space
action_space = gym.spaces.Box(low=-1.0, high=1.0, shape=(action_dim,), dtype=np.float32)

ARGS = {
    'args': args,
    'actor': actor,
    'critic_q1': critic_q1,
    'critic_q2': critic_q2,
    'critic_v': critic_v,
    'actor_optim': actor_optim,
    'critic_q1_optim': critic_q1_optim,
    'critic_q2_optim': critic_q2_optim,
    'critic_v_optim': critic_v_optim,
    'action_space': action_space,
    'tau': 0.005,
    'gamma': 0.99,
    'expectile': 0.8,
    'temperature': 0.1,
    'device': 'cpu'
}
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 IQLPolicy — 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 IQLPolicy 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
ImplicitQLearning Ran
ran on a synthesized input · constructed an object; no result was computed
gwthomas/iql-pytorch/src/iql.py
code served (permissive licence) · get_code("27ef9688ee8bc0c2")
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, ImplicitQLearning: 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 torch.optim as optim

torch.manual_seed(0)

# Define minimal Q-function model
class QFunction(nn.Module):
    def __init__(self, obs_dim, action_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim + action_dim, 16),
            nn.ReLU(),
            nn.Linear(16, 1)
        )
        # Need two Q-networks for self.qf.both()
        self.q1 = nn.Linear(16, 1)
        self.q2 = nn.Linear(16, 1)
    
    def forward(self, observations, actions):
        x = torch.cat([observations, actions], dim=-1)
        return self.net(x)
    
    def both(self, observations, actions):
        x = torch.cat([observations, actions], dim=-1)
        hidden = self.net[:-1](x)  # all layers except last
        q1 = self.q1(hidden)
        q2 = self.q2(hidden)
        return [q1, q2]

# Define minimal V-function model
class VFunction(nn.Module):
    def __init__(self, obs_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim, 16),
            nn.ReLU(),
            nn.Linear(16, 1)
        )
    
    def forward(self, observations):
        return self.net(observations)

# Define minimal Policy model - returns a tensor
class Policy(nn.Module):
    def __init__(self, obs_dim, action_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim, 16),
            nn.ReLU(),
            nn.Linear(16, action_dim)
        )
    
    def forward(self, observations):
        return self.net(observations)

# Build model instances
obs_dim = 4
action_dim = 3
qf = QFunction(obs_dim, action_dim)
vf = VFunction(obs_dim)
policy = Policy(obs_dim, action_dim)

# Define optimizer factory
def optimizer_factory(params):
    return optim.Adam(params, lr=1e-3)

max_steps = 100
tau = 0.7
beta = 3.0
discount = 0.99
alpha = 0.005

ARGS = {
    'qf': qf,
    'vf': vf,
    'policy': policy,
    'optimizer_factory': optimizer_factory,
    'max_steps': max_steps,
    'tau': tau,
    'beta': beta,
    'discount': discount,
    'alpha': alpha
}
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 ImplicitQLearning — 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 ImplicitQLearning 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
ImplicitQLearning Ran
ran on a synthesized input · constructed an object; no result was computed
linhlpv/Offline-and-OfflineOnline-RL/IQL/iql.py
pointer only (licence: NONE) · get_code("99526660d7c044e6")
How it ran

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

ImplicitQLearning Ran
ran on a synthesized input · constructed an object; no result was computed
corl-team/CORL/algorithms/offline/iql.py
code served (permissive licence) · get_code("73d62bef000c40fa")
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, ImplicitQLearning: 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 torch.optim as optim

torch.manual_seed(0)

# Define small neural networks that match the expected interface
class QNetwork(nn.Module):
    def __init__(self, state_dim=4, action_dim=3):
        super().__init__()
        self.fc = nn.Linear(state_dim + action_dim, 1)
        self.fc2 = nn.Linear(state_dim + action_dim, 1)
    
    def forward(self, state, action):
        x = torch.cat([state, action], dim=-1)
        return self.fc(x)
    
    def both(self, state, action):
        x = torch.cat([state, action], dim=-1)
        return [self.fc(x), self.fc2(x)]

class VNetwork(nn.Module):
    def __init__(self, state_dim=4):
        super().__init__()
        self.fc = nn.Linear(state_dim, 1)
    
    def forward(self, state):
        return self.fc(state)

class ActorNetwork(nn.Module):
    def __init__(self, state_dim=4, action_dim=3):
        super().__init__()
        self.fc = nn.Linear(state_dim, action_dim)
    
    def forward(self, state):
        return self.fc(state)

# Instantiate networks
state_dim = 4
action_dim = 3
max_action = 1.0

actor = ActorNetwork(state_dim=state_dim, action_dim=action_dim)
q_network = QNetwork(state_dim=state_dim, action_dim=action_dim)
v_network = VNetwork(state_dim=state_dim)

# Create optimizers
actor_optimizer = optim.Adam(actor.parameters(), lr=1e-3)
q_optimizer = optim.Adam(q_network.parameters(), lr=1e-3)
v_optimizer = optim.Adam(v_network.parameters(), lr=1e-3)

# Build ARGS dictionary
ARGS = {
    'max_action': max_action,
    'actor': actor,
    'actor_optimizer': actor_optimizer,
    'q_network': q_network,
    'q_optimizer': q_optimizer,
    'v_network': v_network,
    'v_optimizer': v_optimizer,
    'iql_tau': 0.7,
    'beta': 3.0,
    'max_steps': 1000,
    'discount': 0.99,
    'tau': 0.005,
    'device': 'cpu'
}
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 ImplicitQLearning — 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 ImplicitQLearning 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
MLP Ran
ran on a synthesized input · constructed an object; no result was computed
orrivlin/implicit-q-learning/IQL.py
pointer only (licence: NONE) · get_code("43876c48b7ed9f0e")
How it ran

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

MLP Ran
ran on a synthesized input · constructed an object; no result was computed
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("e8ccb12a6101441f")
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, MLP: 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
from typing import List, Sequence, Union, Optional, Type

torch.manual_seed(0)

ModuleType = Type[nn.Module]

ARGS = {
    'input_dim': 4,
    'output_dim': 3,
    'hidden_dims': [8, 6],
    'norm_layer': nn.LayerNorm,
    'activation': nn.ReLU,
    'dropout': 0.1,
    'device': 'cpu',
    'linear_layer': nn.Linear,
}
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 MLP — 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 MLP 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
MLP Ran
ran on a synthesized input · constructed an object; no result was computed
Manchery/iql-pytorch/IQL.py
pointer only (licence: NONE) · get_code("7681050968341abc")
How it ran

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

Value Ran
ran on a synthesized input · constructed an object; no result was computed
orrivlin/implicit-q-learning/IQL.py
pointer only (licence: NONE) · get_code("ab256778314dd6eb")
How it ran

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

Value Ran
ran on a synthesized input · constructed an object; no result was computed
BY571/Implicit-Q-Learning/agent.py
pointer only (licence: NONE) · get_code("f90b550029795ff8")
How it ran

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

ValueCritic Ran
ran on a synthesized input · constructed an object; no result was computed
Manchery/iql-pytorch/IQL.py
pointer only (licence: NONE) · get_code("03c7a0d62a9a41b5")
How it ran

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

asymmetric_l2_loss Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from thu-ml/srpo
pointer only · get_code("579d77f78c03773e")
How it ran

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

asymmetric_l2_loss Ran
ran; our contract draft was wrong, not the code
linhlpv/Offline-and-OfflineOnline-RL/IQL/iql.py
pointer only (licence: NONE) · get_code("b2bdeb779182394b")
How it ran

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

convert_to_seconds Ran
ran on a synthesized input
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/ac_env.py
code served (permissive licence) · get_code("e30a96134d01076a")
How it ran

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

import torch

# Define the argument for the convert_to_seconds function
# The function expects a time_str in "minutes:seconds:milliseconds" format

ARGS = {
    "time_str": "2:30:500"
}
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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_to_tensor Ran
ran; our contract draft was wrong, not the code
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("dbb570ccd708ff1e")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Test case 1: torch.Tensor input
tensor_obj = torch.randn(2, 4)

# Test case 2: numpy array input
numpy_obj = np.random.randn(2, 4).astype(np.float32)

# Device to use (CPU only)
device = 'cpu'

# Create ARGS dict with both test cases
# We'll test with the tensor case first
ARGS = {
    'obj': tensor_obj,
    'device': device
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
curvature_splines Ran
ran on a synthesized input
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/curvature.py
code served (permissive licence) · get_code("b67b22a168cce1a0")
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 (20,) 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
from scipy.interpolate import UnivariateSpline

# Create sample 2D curve data
n_points = 20
t = np.linspace(0, 2 * np.pi, n_points)

# Generate a simple curve (circle-like parametric curve)
x = np.cos(t) + np.random.normal(0, 0.01, n_points)
y = np.sin(t) + np.random.normal(0, 0.01, n_points)

# Ensure data is float type
x = x.astype(np.float64)
y = y.astype(np.float64)

ARGS = {
    'x': x,
    'y': y,
    'error': 0.1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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 (20,) — shape (20,) 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
decode_string Ran
ran on a synthesized input
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/motec_ldparser.py
code served (permissive licence) · get_code("4a012f1a3bd772ba")
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)

# The function decode_string takes bytes as input and decodes them as ASCII
# It removes trailing zeros and whitespace
# We need to create bytes objects to test this

ARGS = {
    'bytes': b'hello\x00\x00'
}
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
distance Ran
ran on a synthesized input
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/gap_cpu.py
code served (permissive licence) · get_code("9c4866bb7ea6847e")
How it ran

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

import numpy as np

# Create sample arguments for the distance function
# distance(p0, p1) expects two points/vectors

# p0 and p1 should be numpy arrays where we can compute vector differences
# and then compute the length along axis=1, so they need shape (batch_size, dimensions)

p0 = np.array([[1.0, 2.0, 3.0, 4.0],
               [5.0, 6.0, 7.0, 8.0]], dtype=np.float32)

p1 = np.array([[2.0, 3.0, 4.0, 5.0],
               [6.0, 7.0, 8.0, 9.0]], dtype=np.float32)

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

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

import torch

torch.manual_seed(0)

# distance(p0, p1) calls vector(p0, p1) which subtracts p1 - p0
# vector then calls length() which does torch.sqrt(torch.sum(torch.square(v), axis=1))
# This means v must be a 2D tensor where axis=1 makes sense
# So p0 and p1 should be 2D tensors with shape (batch, dim)

p0 = torch.randn(2, 4)
p1 = torch.randn(2, 4)

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

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

expectile_regression Ran
ran; our contract draft was wrong, not the code
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("d65d964e0519b495")
How it ran

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

import torch

torch.manual_seed(0)

# Create small tensors for predictions and targets
# Using batch size 2 and dimension 4
pred = torch.randn(2, 4)
target = torch.randn(2, 4)
expectile = 0.5

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

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

import tempfile
from pathlib import Path
import yaml

# Create a temporary directory and YAML file for testing
temp_dir = tempfile.TemporaryDirectory()
temp_path = Path(temp_dir.name)

# Create the dataset directory structure
dataset_path = temp_path / "dataset"
dataset_path.mkdir(exist_ok=True)

track_name = "track1"
car_name = "car1"

track_car_dir = dataset_path / track_name / car_name
track_car_dir.mkdir(parents=True, exist_ok=True)

# Create sample data structure
data = {
    "track1": {
        "car1": [
            {"id": "path1"},
            {"id": "path2"}
        ]
    }
}

# Write YAML file
yaml_file = temp_path / "config.yml"
with open(yaml_file, 'w') as f:
    yaml.dump(data, f)

# Define arguments for the function
ARGS = {
    "dataset_path": dataset_path,
    "file": yaml_file,
    "track": "track1",
    "car": "car1"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
yaml — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_smooth_yaw Ran
ran on a synthesized input
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/motec_loader.py
code served (permissive licence) · get_code("9a868703a6f4ebc5")
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 (99,) 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
from scipy.signal import savgol_filter

np.random.seed(0)

# Create sample x and y arrays
# The function expects 1D arrays that are long enough for savgol_filter
# window_length=50 requires at least 50 points
x = np.linspace(0, 10, 100)
y = np.sin(x) + np.random.normal(0, 0.1, 100)

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

import numpy as np

# Create small numpy arrays for x and y coordinates
# The function uses np.diff() which requires arrays with at least 2 elements
x = np.array([0.0, 1.0, 2.0, 3.0])
y = np.array([0.0, 1.5, 2.2, 4.1])

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

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

import numpy as np

# The function `length` takes a vector v and computes the L2 norm along axis 1
# It expects v to be a 2D array where each row is a vector
# The function uses: np.sum with axis=1, np.square, np.sqrt

# Create a small 2D array with shape (2, 4) - batch size 2, dimension 4
v = np.array([
    [1.0, 2.0, 3.0, 4.0],
    [2.0, 2.0, 1.0, 0.0]
], dtype=np.float32)

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

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

import torch

torch.manual_seed(0)

# The function `length` takes a vector v and computes the L2 norm along axis 1
# It expects v to be a 2D tensor (batch_size, features)
# Returns a 1D tensor of length batch_size

v = torch.randn(2, 4)

ARGS = {
    "v": v
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_yaml Ran
ran; our contract draft was wrong, not the code
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/ac_env.py
pointer only (licence: MIT); the stored copy get_code serves, from TangJiakai/GenSim, is pointer only (licence: NONE) · get_code("cfb2071ad5f20847")
How it ran

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

loss Ran
ran; our contract draft was wrong, not the code
Manchery/iql-pytorch/IQL.py
pointer only (licence: NONE) · get_code("162c85e425a085c5")
How it ran

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

make_target Ran
ran; our contract draft was wrong, not the code
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("553f6d4d94d916a1")
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 SimpleModel. 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 copy

torch.manual_seed(0)

# Create a simple neural network module
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(4, 3)
        self.linear2 = nn.Linear(3, 2)
    
    def forward(self, x):
        x = self.linear1(x)
        x = self.linear2(x)
        return x

# Instantiate the model
m = SimpleModel()

# The function make_target takes an nn.Module and:
# 1. Deep copies it
# 2. Sets requires_grad_(False) on the copy
# 3. Calls eval() on the copy
# 4. Returns the copy

ARGS = {
    "m": m
}
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 SimpleModel — a SimpleModel output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleModel 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
miniblock Ran
ran; our contract draft was wrong, not the code
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("be003e2209473d34")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    "input_dim": 64,
    "output_dim": 32,
    "norm_layer": nn.LayerNorm,
    "activation": nn.ReLU,
    "dropout": 0.5,
    "linear_layer": nn.Linear,
}
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 list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
read_yml Ran
ran on a synthesized input
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/data_loader.py
code served (permissive licence) · get_code("e10139c8cfcc9897")
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 yaml
import tempfile
import os

# Create a temporary YAML file with valid content
temp_dir = tempfile.mkdtemp()
yaml_file = os.path.join(temp_dir, "test.yml")

yaml_content = {
    "key1": "value1",
    "key2": 42,
    "nested": {
        "subkey": "subvalue"
    }
}

with open(yaml_file, 'w') as f:
    yaml.dump(yaml_content, f)

ARGS = {
    "f": yaml_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
yaml — 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
seconds_to_mm_ss_mmm Ran
ran on a synthesized input
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/data_loader.py
code served (permissive licence) · get_code("b9421a30c9ec520e")
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

def seconds_to_mm_ss_mmm(seconds):
    minutes = int(seconds // 60)
    remaining_seconds = seconds % 60
    return f'{minutes:2d}:{remaining_seconds:06.3f}'

ARGS = {
    'seconds': 125.456
}
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
vector Ran
ran on a synthesized input
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/gap_cpu.py
code served (permissive licence) · get_code("5fbcfd39eca9be93")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# The function vector(b, e) simply returns e - b
# Both b and e should be compatible for subtraction
# They could be tensors, numpy arrays, or numbers

# Create small tensors for b and e
b = torch.tensor([1.0, 2.0, 3.0, 4.0])
e = torch.tensor([5.0, 6.0, 7.0, 8.0])

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

no invocation recorded.

BasePolicy Not yet run
unverified (harvested, no recorded run)
runamu/compositional-conservatism/offlinerlkit/policy/model_free/iql.py
code served (permissive licence) · get_code("7c0883f7901f1f98")
How it ran

no invocation recorded.

DeterministicActor Not yet run
unverified (harvested, no recorded run)
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("8f18a6efeac4cf16")
How it ran

no invocation recorded.

EnsembleMLP Not yet run
unverified (harvested, no recorded run)
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("6970e6937dbee5a6")
How it ran

no invocation recorded.

GaussianActor Not yet run
unverified (harvested, no recorded run)
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("1ea93cbf319bab05")
How it ran

no invocation recorded.

IQL Not yet run
unverified (harvested, no recorded run)
orrivlin/implicit-q-learning/IQL.py
pointer only (licence: NONE) · get_code("09d15343fe38fa60")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, orrivlin/implicit-q-learning 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. No invocation recorded.

IQL Not yet run
unverified (harvested, no recorded run)
zzmtsvv/rl_task/iql/iql.py
pointer only (licence: NONE) · get_code("93fc887b580bd5ce")
How it ran

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

IQLPolicy Not yet run
unverified (harvested, no recorded run)
typoverflow/OfflineRL-Lib/offlinerllib/policy/model_free/iql.py
code served (permissive licence) · get_code("a369d99da375c4a9")
How it ran

no invocation recorded.

get_gap Not yet run
unverified (harvested, no recorded run)
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/gap.py
code served (permissive licence) · get_code("008fedc7a27baf05")
How it ran

no invocation recorded.

iql_config Not yet run
unverified (harvested, no recorded run)
zzmtsvv/rl_task/iql/iql.py
pointer only (licence: NONE) · get_code("26547f61628cbc43")
How it ran

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

read_channels Not yet run
unverified (harvested, no recorded run)
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/motec_ldparser.py
code served (permissive licence) · get_code("b7d05dedb09fbc7e")
How it ran

no invocation recorded.

read_ldfile Not yet run
unverified (harvested, no recorded run)
dasgringuen/assetto_corsa_gym/assetto_corsa_gym/AssettoCorsaEnv/motec_ldparser.py
code served (permissive licence) · get_code("3f617b1c2021d06a")
How it ran

no invocation recorded.

update_exponential_moving_average Not yet run
unverified (harvested, no recorded run)
gwthomas/iql-pytorch/src/iql.py
code served (permissive licence) · get_code("ba061d6a7ffd45bf")
How it ran

no invocation recorded.

Also present in other papers' code

Of 58 samples lifted from this paper's linked repositories, 58 carry a function identity and 0 do not. Of the 56 distinct functions with an identity, 16 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 1 the same month, 16 later) and 40 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
BasePolicy
brick of this paper's assembly: helper
9 other papers
3 dated earlier, 1 the same month, 5 later · 6 only as an assembly brick
2005.13239 (2020-05)
MOPO: Model-based Offline Policy Optimization
2006.04779 (2020-06)
Conservative Q-Learning for Offline Reinforcement Learning
2102.08363 (2021-02)
COMBO: Conservative Offline Model-Based Policy Optimization
and 6 more not named here
asymmetric_l2_loss
brick of this paper's assembly: loss
6 other papers
6 later · 2 only as an assembly brick
2210.08323 (2022-10)
A Policy-Guided Imitation Approach for Offline Reinforcement Learning
2310.07297 (2023-10)
Score Regularized Policy Optimization through Diffusion Behavior
2407.09024 (2024-07)
Aligning Diffusion Behaviors with Q-functions for Efficient Continuous Control
and 3 more not named here
Critic
brick of this paper's assembly: model
5 other papers
1 dated earlier, 4 later · 3 only as an assembly brick
2002.09505 (2020-02)
Estimating Q(s, s ) with Deep Deterministic Dynamics Gradients
2206.04745 (2022-06)
Mildly Conservative Q-Learning for Offline Reinforcement Learning
2306.06569 (2023-06)
Policy Regularization with Dataset Constraint for Offline Reinforcement Learning
and 2 more not named here
update_exponential_moving_average
brick of this paper's assembly: update_rule
4 other papers
4 later · 4 only as an assembly brick
2210.08323 (2022-10)
A Policy-Guided Imitation Approach for Offline Reinforcement Learning
2212.00124 (2022-12)
One Risk to Rule Them All: A Risk-Sensitive Perspective on Model-Based Offline Reinforcement Learning
2302.00935 (2023-02)
Policy Expansion for Bridging Offline-to-Online Reinforcement Learning
and 1 more not named here
expectile_loss
brick of this paper's assembly: loss
2 other papers
2 later
2402.06187 (2024-02)
Premier-TACO is a Few-Shot Policy Learner: Pretraining Multitask Representation via Temporal Action-Driven Contrastive Loss
2608.07870 (2026-08)
V-Simba: Unleashing the Architectural Potential of RL in Visual Continuous Control
BaseActor
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2301.02328 (2023-01)
Extreme Q-Learning: MaxEnt RL without Entropy
BasePolicy
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2301.02328 (2023-01)
Extreme Q-Learning: MaxEnt RL without Entropy
DeterministicActor
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2301.02328 (2023-01)
Extreme Q-Learning: MaxEnt RL without Entropy
EnsembleLinear
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2301.02328 (2023-01)
Extreme Q-Learning: MaxEnt RL without Entropy
EnsembleMLP
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2301.02328 (2023-01)
Extreme Q-Learning: MaxEnt RL without Entropy
GaussianActor
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2301.02328 (2023-01)
Extreme Q-Learning: MaxEnt RL without Entropy
MLP
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2301.02328 (2023-01)
Extreme Q-Learning: MaxEnt RL without Entropy
convert_to_tensor
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2301.02328 (2023-01)
Extreme Q-Learning: MaxEnt RL without Entropy
load_yaml 1 other paper
1 later
2410.04360 (2024-10)
GenSim: A General Social Simulation Platform with Large Language Model based Agents
make_target
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2301.02328 (2023-01)
Extreme Q-Learning: MaxEnt RL without Entropy
miniblock
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2301.02328 (2023-01)
Extreme Q-Learning: MaxEnt RL without Entropy

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

Repositories linked to this paper

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

Abstract

Offline reinforcement learning requires reconciling two conflicting aims: learning a policy that improves over the behavior policy that collected the dataset, while at the same time minimizing the deviation from the behavior policy so as to avoid errors due to distributional shift. This trade-off is critical, because most current offline reinforcement learning methods need to query the value of unseen actions during training to improve the policy, and therefore need to either constrain these actions to be in-distribution, or else regularize their values. We propose a new offline RL method that never needs to evaluate actions outside of the dataset, but still enables the learned policy to improve substantially over the best behavior in the data through generalization. The main insight in our work is that, instead of evaluating unseen actions from the latest policy, we can approximate the policy improvement step implicitly by treating the state value function as a random variable, with randomness determined by the action (while still integrating over the dynamics to avoid excessive optimism), and then taking a state conditional upper expectile of this random variable to estimate the value of the best actions in that state. This leverages the generalization capacity of the function approximator to estimate the value of the best available action at a given state without ever directly querying a Q-function with this unseen action. Our algorithm alternates between fitting this upper expectile value function and backing it up into a Q-function, without any explicit policy. Then, we extract the policy via advantage-weighted behavioral cloning, which also avoids querying out-of-sample actions. We dub our method implicit Q-learning (IQL). IQL is easy to implement, computationally efficient, and only requires fitting an additional critic with an asymmetric L2 loss. 1 IQL demonstrates the state-of-the-art performance on D4RL, a standard benchmark for offline reinforcement learning. We also demonstrate that IQL achieves strong performance fine-tuning using online interaction after offline initialization.

For agents

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

get_harvested_code_for_paper("2110.06169")
get_code_for_paper("2110.06169")
have("2110.06169")

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

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

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

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

Connect an agent — have() is free.