| AdamsBashforth |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("7980b2520b28c2f2") How it ranRan 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, AdamsBashforth: 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 abc
torch.manual_seed(0)
def _handle_unused_kwargs(self, unused_kwargs):
pass
def _assert_increasing(t):
pass
class SimpleODEFunc(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
return self.linear(y[0]).unsqueeze(0)
class ConcreteFixedGridODESolver:
def __init__(self, func, y0, step_size=None, grid_constructor=None, **unused_kwargs):
unused_kwargs.pop('rtol', None)
unused_kwargs.pop('atol', None)
_handle_unused_kwargs(self, unused_kwargs)
del unused_kwargs
self.func = func
self.y0 = y0
if step_size is not None and grid_constructor is None:
self.grid_constructor = self._grid_constructor_from_step_size(step_size)
elif grid_constructor is None:
self.grid_constructor = lambda f, y0, t: t
else:
raise ValueError('step_size and grid_constructor are exclusive arguments.')
def _grid_constructor_from_step_size(self, step_size):
def _grid_constructor(func, y0, t):
start_time = t[0]
end_time = t[-1]
niters = torch.ceil((end_time - start_time) / step_size + 1).item()
t_infer = torch.arange(0, niters).to(t) * step_size + start_time
if t_infer[-1] > t[-1]:
t_infer[-1] = t[-1]
return t_infer
return _grid_constructor
@property
def order(self):
return 1
def step_func(self, func, t, dt, y):
return tuple(torch.zeros_like(y_) for y_ in y)
func = SimpleODEFunc()
y0 = (torch.randn(2, 4),)
step_size = 0.1
ARGS = {
'func': func,
'y0': y0,
'step_size': step_size,
'grid_constructor': 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 AdamsBashforth — 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 AdamsBashforth 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
|
| AdamsBashforth |
Ran ran on a synthesized input · constructed an object; no result was computed |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("106d95c9ca4a144c") How it ranRan 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, AdamsBashforth: 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 abc
torch.manual_seed(0)
def _handle_unused_kwargs(self, unused_kwargs):
pass
def _assert_increasing(t):
pass
class SimpleODEFunc(nn.Module):
def __init__(self):
super(SimpleODEFunc, self).__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
return self.linear(y)
class ConcreteODESolver(object):
__metaclass__ = abc.ABCMeta
def __init__(self, func, y0, step_size=None, grid_constructor=None, **unused_kwargs):
unused_kwargs.pop('rtol', None)
unused_kwargs.pop('atol', None)
_handle_unused_kwargs(self, unused_kwargs)
del unused_kwargs
self.func = func
self.y0 = y0
if step_size is not None and grid_constructor is None:
self.grid_constructor = self._grid_constructor_from_step_size(step_size)
elif grid_constructor is None:
self.grid_constructor = lambda f, y0, t: t
else:
raise ValueError('step_size and grid_constructor are exclusive arguments.')
def _grid_constructor_from_step_size(self, step_size):
def _grid_constructor(func, y0, t):
start_time = t[0]
end_time = t[-1]
niters = torch.ceil((end_time - start_time) / step_size + 1).item()
t_infer = torch.arange(0, niters).to(t) * step_size + start_time
t_infer[-1] = t[-1]
return t_infer
return _grid_constructor
@property
def order(self):
return 1
def step_func(self, func, t, dt, y):
return tuple(torch.zeros_like(y_) for y_ in y)
def integrate(self, t):
_assert_increasing(t)
t = t.type_as(self.y0[0])
time_grid = self.grid_constructor(self.func, self.y0, t)
assert time_grid[0] == t[0] and time_grid[-1] == t[-1], f'{time_grid[0]}!={t[0]}, {time_grid[-1]}!={t[-1]}'
time_grid = time_grid.to(self.y0[0])
solution = [self.y0]
j = 1
y0 = self.y0
for t0, t1 in zip(time_grid[:-1], time_grid[1:]):
dy = self.step_func(self.func, t0, t1 - t0, y0)
y1 = tuple((y0_ + dy_ for y0_, dy_ in zip(y0, dy)))
y0 = y1
while j < len(t) and t1 >= t[j]:
solution.append(self._linear_interp(t0, t1, y0, y1, t[j]))
j += 1
return tuple(map(torch.stack, tuple(zip(*solution))))
def _linear_interp(self, t0, t1, y0, y1, t):
if t == t0:
return y0
if t == t1:
return y1
t0, t1, t = (t0.to(y0[0]), t1.to(y0[0]), t.to(y0[0]))
slope = tuple(((y1_ - y0_) / (t1 - t0) for y0_, y1_ in zip(y0, y1)))
return tuple((y0_ + slope_ * (t - t0) for y0_, slope_ in zip(y0, slope)))
func = SimpleODEFunc()
y0 = (torch.randn(2, 4), torch.randn(2, 4))
step_size = 0.1
t = torch.linspace(0.0, 1.0, 5)
ARGS = {
'func': func,
'y0': y0,
'step_size': step_size,
'grid_constructor': 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 AdamsBashforth — 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 AdamsBashforth 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
|
| AdamsBashforthMoulton |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("1cbcd7f7db72e996") How it ranRan 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, AdamsBashforthMoulton: 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)
# Helper function that the code uses
def _handle_unused_kwargs(obj, kwargs):
if kwargs:
raise ValueError(f'Unexpected keyword arguments: {list(kwargs.keys())}')
def _assert_increasing(t):
if not torch.all(t[1:] > t[:-1]):
raise ValueError('t must be strictly increasing')
# Define a simple ODE function
class SimpleODEFunc(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors
return tuple(self.linear(y_i) for y_i in y)
# Create initial state y0 as a tuple of tensors
y0 = (torch.randn(2, 4), torch.randn(2, 4))
# Create the ODE function
func = SimpleODEFunc()
# Create time points
t = torch.linspace(0, 1, 5)
# Arguments for FixedGridODESolver.__init__
ARGS = {
'func': func,
'y0': y0,
'step_size': 0.1,
'grid_constructor': 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 AdamsBashforthMoulton — 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 AdamsBashforthMoulton 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
|
| AdamsBashforthMoulton |
Ran ran on a synthesized input · constructed an object; no result was computed |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("279f4f78d04ad28b") How it ranRan 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, AdamsBashforthMoulton: 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)
def _handle_unused_kwargs(obj, kwargs):
if kwargs:
raise ValueError(f'Unexpected keyword arguments: {list(kwargs.keys())}')
def _assert_increasing(t):
if not torch.all(t[1:] > t[:-1]):
raise ValueError('t must be strictly increasing')
class SimpleFunc(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors
return tuple(self.linear(y_i) for y_i in y)
func = SimpleFunc()
y0 = (torch.randn(4), torch.randn(4))
t = torch.tensor([0.0, 0.5, 1.0, 1.5, 2.0])
ARGS = {
'func': func,
'y0': y0,
'step_size': 0.1,
'grid_constructor': 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 AdamsBashforthMoulton — 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 AdamsBashforthMoulton 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
|
| AdaptiveStepsizeODESolver |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("e8208a8b9886cd85") How it ranRan 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, AdaptiveStepsizeODESolver: 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)
# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
def __init__(self):
super(SimpleODEFunc, self).__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a list or tuple of tensors
if isinstance(y, (list, tuple)):
return [self.linear(yi) for yi in y]
else:
return self.linear(y)
# Create function instance
func = SimpleODEFunc()
# Create initial conditions y0 as a list of tensors (batch_size=2, dim=4)
y0 = [torch.randn(2, 4), torch.randn(2, 4)]
# Tolerance parameters
atol = 1e-6
rtol = 1e-5
ARGS = {
'func': func,
'y0': y0,
'atol': atol,
'rtol': rtol,
}
- 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 AdaptiveStepsizeODESolver — 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 AdaptiveStepsizeODESolver 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
|
| AdaptiveStepsizeODESolver |
Ran ran on a synthesized input · constructed an object; no result was computed |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("2f5e41ed5c35fa64") How it ranRan 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, AdaptiveStepsizeODESolver: 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 SimpleODEFunc(nn.Module):
"""Minimal ODE function that returns y-shaped output"""
def __init__(self, hidden_dim):
super(SimpleODEFunc, self).__init__()
self.hidden_dim = hidden_dim
def forward(self, t, y):
# Returns a tensor of same shape as y
return -y
# Create tiny test tensors
batch_size = 2
state_dim = 4
y0 = [torch.randn(batch_size, state_dim)]
# Create the ODE function
func = SimpleODEFunc(state_dim)
# Tolerance parameters
atol = 1e-6
rtol = 1e-3
ARGS = {
"func": func,
"y0": y0,
"atol": atol,
"rtol": rtol,
}
- 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 AdaptiveStepsizeODESolver — 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 AdaptiveStepsizeODESolver 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
|
| CortexODE |
Ran ran on a synthesized input · constructed an object; no result was computed |
m-qiang/cortexode/model/net.py pointer only (licence: NONE) · get_code("042c58847599eec2") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, m-qiang/cortexode 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. |
| DAFT |
Ran ran on a synthesized input · constructed an object; no result was computed |
kakao/DAFT/model.py code served (permissive licence) · get_code("43b0462e8ae59a39") How it ranRan 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, DAFT: 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 torch.nn.init import xavier_uniform_
torch.manual_seed(0)
def linear(in_dim, out_dim, bias=True):
lin = nn.Linear(in_dim, out_dim, bias=bias)
xavier_uniform_(lin.weight)
if bias:
lin.bias.data.zero_()
return lin
class DAFT(nn.Module):
def __init__(self, dim):
super().__init__()
self.attn = linear(dim + 1, 1)
self.different_question_projs = linear(dim + 1, dim)
self.nfe = 0
def set_context(self, context, question):
self.context = context
self.question = question
def forward(self, t, attn_weight):
self.nfe += 1
tt = torch.ones_like(self.question[:, :1]) * t
ttx = torch.cat([tt, self.question], dim=1)
question = self.different_question_projs(ttx)
context_prod = question.unsqueeze(1) * self.context
context_prod = torch.cat([context_prod, attn_weight], dim=2)
attn_weight_diff = self.attn(context_prod)
return attn_weight_diff
# Create a DAFT instance with dim=4
dim = 4
daft_model = DAFT(dim=dim)
# Set context and question for the model
batch_size = 2
context_len = 3
question_dim = dim
# context shape: (batch_size, context_len, question_dim)
context = torch.randn(batch_size, context_len, question_dim)
# question shape: (batch_size, question_dim)
question = torch.randn(batch_size, question_dim)
daft_model.set_context(context, question)
# Create arguments for forward pass
t = 0.5
# attn_weight shape: (batch_size, context_len, 1)
attn_weight = torch.randn(batch_size, context_len, 1)
ARGS = {
"dim": dim,
}
- 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 DAFT — 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 DAFT 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
|
| Data |
Ran ran on a synthesized input · constructed an object; no result was computed |
UofTrees/ProjectX2020/mr_node/model/odefunc.py pointer only (licence: NONE) · get_code("afcd5754477bf8a7") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, UofTrees/ProjectX2020 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. |
| DiffEqWrapper |
Ran ran; our contract draft was wrong, not the code |
xwinxu/bayesian-sde/brax/_impl/diffeq_layers.py code served (permissive licence) · get_code("b4e4766812fea13a") How it ranRan 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 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)
# Create a simple layer function pair (init_fun, layer_apply_fun)
# The layer_apply_fun takes (params, x, **kwargs) and returns output
def simple_init_fun(key, input_shape):
"""Initialize parameters for a simple linear layer"""
return {'weight': torch.randn(4, 4), 'bias': torch.randn(4)}
def simple_apply_fun(params, x, **kwargs):
"""Apply a simple linear transformation"""
return torch.nn.functional.linear(x, params['weight'], params['bias'])
# Create the layer tuple
layer = (simple_init_fun, simple_apply_fun)
ARGS = {
'layer': layer
}
- 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 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
|
| Dopri5Solver |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("2f030eba6be5e4b6") How it ranRan 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, Dopri5Solver: 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 collections
torch.manual_seed(0)
# Define a simple ODE function
class SimpleODEFunc(nn.Module):
def __init__(self):
super(SimpleODEFunc, self).__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors
if isinstance(y, tuple):
return tuple(self.linear(y_i) for y_i in y)
else:
return self.linear(y)
# Create the ODE function
func = SimpleODEFunc()
# Create initial state y0 as a tuple of tensors
y0 = (torch.randn(2, 4), torch.randn(2, 4))
# Set tolerance parameters
atol = 1e-6
rtol = 1e-3
# Build the ARGS dictionary
ARGS = {
'func': func,
'y0': y0,
'atol': atol,
'rtol': rtol,
}
- 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 Dopri5Solver — 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 Dopri5Solver 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
|
| Dopri5Solver |
Ran ran on a synthesized input · constructed an object; no result was computed |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("f121c10d5d8c5250") How it ranRan 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, Dopri5Solver: 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 collections
torch.manual_seed(0)
# Define a simple ODE function
class SimpleODEFunc(nn.Module):
def __init__(self):
super(SimpleODEFunc, self).__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors
if isinstance(y, tuple):
return tuple(self.linear(y_i) for y_i in y)
else:
return self.linear(y)
# Create function instance
func = SimpleODEFunc()
# Create initial condition - tuple of tensors as expected by integrate()
y0 = (torch.randn(2, 4), torch.randn(2, 4))
# Tolerance parameters
atol = 1e-6
rtol = 1e-5
# Create time points (strictly increasing)
t = torch.linspace(0, 1, 5, dtype=torch.float64)
ARGS = {
'func': func,
'y0': y0,
'atol': atol,
'rtol': rtol,
}
- 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 Dopri5Solver — 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 Dopri5Solver 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
|
| Euler |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("43e9e562dc3f595e") How it ranRan 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, Euler: 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)
# Define a simple ODE function that takes (t, y) and returns derivatives
class SimpleODEFunc(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors
# Return a tuple of derivatives with same structure as y
result = self.linear(y[0])
return (result,)
# Create the function
func = SimpleODEFunc()
# Create initial condition y0 as a tuple of tensors
# Batch size 2, feature dim 4
y0 = (torch.randn(2, 4),)
# Create time grid
t = torch.tensor([0.0, 0.1, 0.2, 0.3, 0.4, 0.5])
ARGS = {
'func': func,
'y0': y0,
'step_size': 0.05,
'grid_constructor': 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 Euler — 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 Euler 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
|
| Euler |
Ran ran on a synthesized input · constructed an object; no result was computed |
alexandrejash/Chivvo/anode/odesolver.py pointer only (licence: GPL-3.0) · get_code("6fba12214cae5e2d") How it ranThe body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, alexandrejash/Chivvo, 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. |
| Euler |
Ran ran on a synthesized input · constructed an object; no result was computed |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("70d97d2f6b74251c") How it ranRan 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, Euler: 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)
# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors
# Return tuple of same structure with derivatives
return tuple(self.linear(y_) for y_ in y)
# Create function instance
func = SimpleODEFunc()
# Initial condition: tuple of 2 tensors, each of shape (2, 4)
# batch_size=2, feature_dim=4
y0 = (torch.randn(2, 4), torch.randn(2, 4))
# Time grid: strictly increasing
t = torch.linspace(0, 1, 5)
# Create Euler solver instance
ARGS = {
'func': func,
'y0': y0,
'step_size': 0.1,
'grid_constructor': 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 Euler — 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 Euler 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
|
| Euler |
Ran ran on a synthesized input · constructed an object; no result was computed |
5yearsKim/HamiltonianFlow/anode/odesolver.py pointer only (licence: GPL-3.0) · get_code("9406c2abc025c528") How it ranThe body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, 5yearsKim/HamiltonianFlow, 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. |
| FixedGridODESolver |
Ran ran on a synthesized input · constructed an object; no result was computed |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("10f0d6dfa6f48005") How it ranRan 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, FixedGridODESolver: 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)
# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors, return tuple of same structure
return (self.linear(y[0]),)
# Create the function
func = SimpleODEFunc()
# Create initial state y0 as a tuple of tensors
# Using shape (2, 4) for batch_size=2, feature_dim=4
y0 = (torch.randn(2, 4),)
# Create time grid - strictly increasing
t = torch.tensor([0.0, 0.5, 1.0, 1.5, 2.0])
# Define step_size for grid construction
step_size = 0.1
ARGS = {
'func': func,
'y0': y0,
'step_size': step_size,
'grid_constructor': 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 FixedGridODESolver — 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 FixedGridODESolver 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
|
| IGrid |
Ran ran on a synthesized input · constructed an object; no result was computed |
TheStageAI/TorchIntegral/torch_integral/model.py code served (permissive licence) · get_code("62feec9141b4e5c3") How it ranRan 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, IGrid: 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)
# IGrid is a base class that doesn't require any __init__ parameters
# beyond what's inherited from nn.Module
# The forward() method checks self.curr_grid and calls generate_grid() if needed
# The class uses self.curr_grid and self.eval_size attributes
# Since this is a base class with no parameters to __init__,
# ARGS should be an empty dict
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 IGrid — 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 IGrid 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 |
ipeter50/graph_ode/odegnn.py code served (permissive licence) · get_code("a963843951a2916d") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float, shape (2, 5, 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
class MLP(nn.Module):
"""Two-layer fully-connected ELU net with batch norm."""
def __init__(self, n_in, n_hid, n_out, do_prob=0.0):
super(MLP, self).__init__()
self.fc1 = nn.Linear(n_in, n_hid)
self.fc2 = nn.Linear(n_hid, n_out)
self.bn = nn.BatchNorm1d(n_out)
self.dropout_prob = do_prob
self.init_weights()
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Linear):
nn.init.xavier_normal_(m.weight.data)
m.bias.data.fill_(0.1)
elif isinstance(m, nn.BatchNorm1d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def batch_norm(self, inputs):
x = inputs.view(inputs.size(0) * inputs.size(1), -1)
x = self.bn(x)
return x.view(inputs.size(0), inputs.size(1), -1)
def forward(self, inputs):
x = F.elu(self.fc1(inputs))
x = F.dropout(x, self.dropout_prob, training=self.training)
x = F.elu(self.fc2(x))
return self.batch_norm(x)
INIT_ARGS = {
'n_in': 4,
'n_hid': 8,
'n_out': 3,
'do_prob': 0.1,
}
ARGS = {
'inputs': torch.randn(2, 5, 4),
}
if __name__ == '__main__':
model = MLP(**INIT_ARGS)
model.eval()
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 3, dtype family float, shape (2, 5, 3) — shape (2, 5, 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)
|
| Midpoint |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("6a98a0fc2403db3c") How it ranRan 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, Midpoint: 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)
# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors
# Return a tuple of the same structure with gradients
return tuple(self.linear(y_).unsqueeze(0) for y_ in y)
# Create function instance
func = SimpleODEFunc()
# Initial condition: tuple of tensors (batch_size=2, dim=4)
y0 = (torch.randn(2, 4), torch.randn(2, 4))
# Time points (strictly increasing)
t = torch.linspace(0, 1, 5)
ARGS = {
'func': func,
'y0': y0,
'step_size': 0.1,
'grid_constructor': 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 Midpoint — 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 Midpoint 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
|
| Midpoint |
Ran ran on a synthesized input · constructed an object; no result was computed |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("99ec31db7c208dcf") How it ranRan 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, Midpoint: 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)
# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors
# Return a tuple of the same structure with derivatives
return tuple(self.linear(y_) for y_ in y)
# Create the function
func = SimpleODEFunc()
# Create initial conditions as a tuple of tensors
# Using batch size 2, feature dimension 4
y0 = (torch.randn(2, 4), torch.randn(2, 4))
# Create time points (must be strictly increasing)
t = torch.linspace(0, 1, 5)
# Set up arguments for Midpoint solver
ARGS = {
'func': func,
'y0': y0,
'step_size': 0.1,
'grid_constructor': 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 Midpoint — 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 Midpoint 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
|
| ODEAdjoint |
Ran ran on a synthesized input · constructed an object; no result was computed |
feicccccccc/Neural-ODE-Ex/NeuralODE.py code served (permissive licence) · get_code("a932ba75143e9ecb") How it ranRan 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, ODEAdjoint: 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
torch.manual_seed(0)
# Create a simple ODEfunc subclass
class SimpleODEFunc(nn.Module):
def __init__(self, input_dim, hidden_dim):
super().__init__()
self.net = nn.Sequential(
nn.Linear(input_dim, hidden_dim),
nn.Tanh(),
nn.Linear(hidden_dim, input_dim)
)
def forward(self, z, t):
return self.net(z)
def forward_with_grad(self, z, t, grad_outputs):
batch_size = z.shape[0]
out = self.forward(z, t)
a = grad_outputs
adfdz, adfdt, *adfdp = torch.autograd.grad(
(out,),
(z, t) + tuple(self.parameters()),
grad_outputs=a,
allow_unused=True,
retain_graph=True
)
if adfdp is not None:
adfdp = torch.cat([p_grad.flatten() for p_grad in adfdp]).unsqueeze(0)
adfdp = adfdp.expand(batch_size, -1) / batch_size
if adfdt is not None:
adfdt = adfdt.expand(batch_size, 1) / batch_size
return (out, adfdz, adfdt, adfdp)
def flatten_parameters(self):
p_shapes = []
flat_parameters = []
for p in self.parameters():
p_shapes.append(p.size())
flat_parameters.append(p.flatten())
return torch.cat(flat_parameters)
# Create input tensors
batch_size = 2
z_dim = 4
time_steps = 3
z0 = torch.randn(batch_size, z_dim)
t = torch.linspace(0, 1, time_steps).unsqueeze(-1).unsqueeze(-1)
# Create the ODE function
func = SimpleODEFunc(input_dim=z_dim, hidden_dim=8)
# Get flat parameters
flat_parameters = func.flatten_parameters()
# Create gradient tensor for backward
dLdz = torch.randn(time_steps, batch_size, z_dim)
ARGS = {
"z0": z0,
"t": t,
"flat_parameters": flat_parameters,
"func": func
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pydevd, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ODEAdjoint — 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 ODEAdjoint 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
|
| ODEBlock |
Ran ran on a synthesized input · constructed an object; no result was computed |
kfallah/NODE-Denoiser/models/NODE.py pointer only (licence: NONE) · get_code("59f408ca8aaaf9f3") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, kfallah/NODE-Denoiser 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. |
| ODEBlock |
Ran ran on a synthesized input · constructed an object; no result was computed |
dungxibo123/neural_ode/utils/model.py pointer only (licence: NONE) · get_code("92137b4f2c7365e8") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, dungxibo123/neural_ode 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. |
| ODENet |
Ran ran on a synthesized input · constructed an object; no result was computed |
abaietto/neural_ode_classification/models.py pointer only (licence: NONE) · get_code("6bbb55a0b9a1ee9c") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, abaietto/neural_ode_classification 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. |
| ODENet |
Ran ran on a synthesized input · constructed an object; no result was computed |
boschresearch/numerics_independent_neural_odes/models/models.py pointer only (licence: AGPL-3.0) · get_code("ce3b538793b44a3f") How it ranThe body of this sample is withheld: AGPL-3.0, as GitHub detects it on this paper's repository, boschresearch/numerics_independent_neural_odes, 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. |
| OdeSolver |
Ran ran on a synthesized input · constructed an object; no result was computed |
copperwire/neural_ode/src/ode_solvers/solvers.py pointer only (licence: NONE) · get_code("fd17b14e17a04cc7") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, copperwire/neural_ode 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. |
| ParametrizedModel |
Ran ran on a synthesized input · constructed an object; no result was computed |
TheStageAI/TorchIntegral/torch_integral/model.py code served (permissive licence) · get_code("6a10221436726b78") How it ranRan 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, ParametrizedModel: 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 torch.nn.utils import parametrize
torch.manual_seed(0)
# Create a simple base model
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
# Create a simple parametrization
class SimpleParametrization(nn.Module):
def forward(self, x):
return x * 0.5
# Build the base model
base_model = SimpleModel()
# Add a parametrization to the model
parametrize.register_parametrization(
base_model.linear1,
'weight',
SimpleParametrization(),
unsafe=True
)
ARGS = {
'model': base_model
}
- 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 ParametrizedModel — 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 ParametrizedModel 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
|
| PrunableModel |
Ran ran on a synthesized input · constructed an object; no result was computed |
TheStageAI/TorchIntegral/torch_integral/model.py code served (permissive licence) · get_code("d8a06e2aaf08a085") How it ranRan 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, PrunableModel: 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 torch.nn.utils import parametrize
torch.manual_seed(0)
# Create a simple base model
class SimpleModel(nn.Module):
def __init__(self):
super(SimpleModel, self).__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
# Create a simple group/pruning group class
class PruningGroup(nn.Module):
def __init__(self, name, param_count=10):
super(PruningGroup, self).__init__()
self.name = name
self.param_count = param_count
def forward(self):
# This is called in forward_groups
pass
def count_parameters(self):
return self.param_count
def __call__(self):
return self.forward()
# Create base model instance
base_model = SimpleModel()
# Create pruning groups with different parameter counts
group1 = PruningGroup("group1", param_count=5)
group2 = PruningGroup("group2", param_count=15)
group3 = PruningGroup("group3", param_count=10)
groups = [group1, group2, group3]
ARGS = {
'model': base_model,
'groups': groups
}
- 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 PrunableModel — 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 PrunableModel 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
|
| RK2 |
Ran ran on a synthesized input · constructed an object; no result was computed |
alexandrejash/Chivvo/anode/odesolver.py pointer only (licence: GPL-3.0) · get_code("5512b8d472ebad2a") How it ranThe body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, alexandrejash/Chivvo, 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. |
| RK2 |
Ran ran on a synthesized input · constructed an object; no result was computed |
5yearsKim/HamiltonianFlow/anode/odesolver.py pointer only (licence: GPL-3.0) · get_code("33a0d576e23c028f") How it ranThe body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, 5yearsKim/HamiltonianFlow, 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. |
| RK4 |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("26fbbe135361b126") How it ranRan 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, RK4: 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 warnings
import abc
torch.manual_seed(0)
# Mock rk_common module
class rk_common:
@staticmethod
def rk4_alt_step_func(func, t, dt, y):
# Simple mock implementation that returns a tuple of zero tensors with same shape as y
return tuple(torch.zeros_like(y_i) for y_i in y)
# Define a simple ODE function
class SimpleODEFunc(nn.Module):
def __init__(self):
super(SimpleODEFunc, self).__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple, convert to tensor for processing
if isinstance(y, tuple):
y_tensor = y[0]
else:
y_tensor = y
return (self.linear(y_tensor),)
# Create function instance
func = SimpleODEFunc()
# Create initial state y0 as a tuple of tensors
y0 = (torch.randn(2, 4),)
# Create time grid
t = torch.tensor([0.0, 0.5, 1.0, 1.5, 2.0])
# Construct ARGS dict for RK4.__init__
ARGS = {
'func': func,
'y0': y0,
'step_size': 0.1,
'grid_constructor': 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 RK4 — 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 RK4 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
|
| RK4 |
Ran ran on a synthesized input · constructed an object; no result was computed |
alexandrejash/Chivvo/anode/odesolver.py pointer only (licence: GPL-3.0) · get_code("127c92027e96c4f8") How it ranThe body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, alexandrejash/Chivvo, 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. |
| RK4 |
Ran ran on a synthesized input · constructed an object; no result was computed |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("52750e1480f37d55") How it ranRan 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, RK4: 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 warnings
import abc
torch.manual_seed(0)
# Mock rk_common module since RK4 references it
class rk_common:
@staticmethod
def rk4_alt_step_func(func, t, dt, y):
# Simple mock implementation that returns a tuple of zero deltas
return tuple(torch.zeros_like(y_) for y_ in y)
# Define a simple ODE function
class SimpleODEFunc(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors
# Return dy/dt as a tuple
if isinstance(y, tuple):
combined = torch.cat(y, dim=-1)
result = self.linear(combined)
# Split back into tuple
return (result,)
else:
return (self.linear(y),)
# Create instances
func = SimpleODEFunc()
# y0 should be a tuple of tensors (batch_size=2, features=4)
y0 = (torch.randn(2, 4),)
# Time grid - strictly increasing
t = torch.tensor([0.0, 0.5, 1.0, 1.5, 2.0])
# step_size
step_size = 0.1
# Create the RK4 solver with arguments
ARGS = {
'func': func,
'y0': y0,
'step_size': step_size,
'grid_constructor': 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 RK4 — 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 RK4 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
|
| RK4 |
Ran ran on a synthesized input · constructed an object; no result was computed |
5yearsKim/HamiltonianFlow/anode/odesolver.py pointer only (licence: GPL-3.0) · get_code("1fc91b40082e955e") How it ranThe body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, 5yearsKim/HamiltonianFlow, 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. |
| Time_Stepper |
Ran ran on a synthesized input · constructed an object; no result was computed |
alexandrejash/Chivvo/anode/odesolver.py pointer only (licence: GPL-3.0) · get_code("2c812a9f084716eb") How it ranThe body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, alexandrejash/Chivvo, 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. |
| Time_Stepper |
Ran ran on a synthesized input · constructed an object; no result was computed |
5yearsKim/HamiltonianFlow/anode/odesolver.py pointer only (licence: GPL-3.0) · get_code("78706994d851e4b4") How it ranThe body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, 5yearsKim/HamiltonianFlow, 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. |
| TrainableGrid1D |
Ran ran on a synthesized input · constructed an object; no result was computed |
TheStageAI/TorchIntegral/torch_integral/model.py code served (permissive licence) · get_code("60b35461edf3f214") How it ranRan 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, TrainableGrid1D: 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)
# Parameters for TrainableGrid1D.__init__
size = 5
init_value = torch.linspace(-1, 1, 5)
ARGS = {
'size': size,
'init_value': init_value
}
- 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 TrainableGrid1D — 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 TrainableGrid1D 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
|
| Tsit5Solver |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("a04d5636674a9ec2") How it ranRan 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, Tsit5Solver: 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)
# Define a simple ODE function that takes t and y and returns dy/dt
class SimpleODEFunc(nn.Module):
def __init__(self):
super(SimpleODEFunc, self).__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y could be a tuple or tensor
if isinstance(y, tuple):
return tuple(self.linear(y_i) for y_i in y)
else:
return self.linear(y)
# Create the ODE function
func = SimpleODEFunc()
# Create initial state y0 as a tuple of tensors
y0 = (torch.randn(2, 4), torch.randn(2, 4))
# Tolerance parameters
atol = 1e-6
rtol = 1e-5
# Create time points (must be strictly increasing)
t = torch.linspace(0, 1, 5, dtype=torch.float64)
ARGS = {
'func': func,
'y0': y0,
'atol': atol,
'rtol': rtol,
}
- 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 Tsit5Solver — 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 Tsit5Solver 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
|
| Tsit5Solver |
Ran ran on a synthesized input · constructed an object; no result was computed |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("a65d81dc9b13762d") How it ranRan 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, Tsit5Solver: 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)
# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors, convert to single tensor for processing
if isinstance(y, tuple):
y_tensor = y[0]
else:
y_tensor = y
return (self.linear(y_tensor),)
# Create the function
func = SimpleODEFunc()
# Create initial state y0 as a tuple of tensors (batch_size=2, dim=4)
y0 = (torch.randn(2, 4),)
# Set tolerance parameters
atol = 1e-6
rtol = 1e-3
ARGS = {
'func': func,
'y0': y0,
'atol': atol,
'rtol': rtol,
}
- 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 Tsit5Solver — 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 Tsit5Solver 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
|
| VariableCoefficientAdamsBashforth |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("180e9fe199764f78") How it ranRan 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, VariableCoefficientAdamsBashforth: 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)
# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
def __init__(self):
super(SimpleODEFunc, self).__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors, return tuple of same structure
if isinstance(y, (tuple, list)):
return tuple(self.linear(y_i) for y_i in y)
else:
return self.linear(y)
# Create ODE function
func = SimpleODEFunc()
# Initial condition - tuple of tensors
y0 = (torch.randn(2, 4), torch.randn(2, 4))
# Tolerances
atol = 1e-6
rtol = 1e-3
# Time points for integration
t = torch.linspace(0, 1, 5, dtype=torch.float64)
ARGS = {
'func': func,
'y0': y0,
'atol': atol,
'rtol': rtol,
't': t,
}
- 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 VariableCoefficientAdamsBashforth — 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 VariableCoefficientAdamsBashforth 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
|
| VariableCoefficientAdamsBashforth |
Ran ran on a synthesized input · constructed an object; no result was computed |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("0875a31606cadf64") How it ranRan 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, VariableCoefficientAdamsBashforth: 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 collections
torch.manual_seed(0)
# Define a simple ODE function
class SimpleODEFunc(nn.Module):
def __init__(self):
super(SimpleODEFunc, self).__init__()
self.linear = nn.Linear(4, 4)
def forward(self, t, y):
# y is a tuple of tensors
if isinstance(y, tuple):
result = tuple(self.linear(y_i) for y_i in y)
else:
result = (self.linear(y),)
return result
# Create test data
func = SimpleODEFunc()
# Initial state y0 as a tuple of tensors (batch_size=2, feature_dim=4)
y0 = (torch.randn(2, 4), torch.randn(2, 4))
# Time points to integrate over
t = torch.linspace(0, 1, 5, dtype=torch.float64)
# Tolerance parameters
atol = 1e-6
rtol = 1e-3
# Build ARGS dictionary
ARGS = {
'func': func,
'y0': y0,
'atol': atol,
'rtol': rtol,
't': t,
}
- 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 VariableCoefficientAdamsBashforth — 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 VariableCoefficientAdamsBashforth 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
|
| VelocityField |
Ran ran on a synthesized input · constructed an object; no result was computed |
tianfr/mononerf/src/model/velocity_field.py pointer only (licence: NOASSERTION) · get_code("f031bcc19da6d85a") How it ranThe body of this sample is withheld: GitHub could not classify the licence of this paper's repository, tianfr/mononerf (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. |
| _RungeKuttaState |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("443bb371b2a31d9b") How it ranRan 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, _RungeKuttaState: 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 collections
torch.manual_seed(0)
# Create sample tensors with distinct dimensions
# y1: function value at end of last time step
y1 = torch.randn(2, 4)
# f1: derivative at end of last time step
f1 = torch.randn(2, 4)
# t0: scalar float64 tensor, start of last time step
t0 = torch.tensor(0.0, dtype=torch.float64)
# t1: scalar float64 tensor, end of last time step
t1 = torch.tensor(0.1, dtype=torch.float64)
# dt: scalar float64 tensor, size for next time step
dt = torch.tensor(0.05, dtype=torch.float64)
# interp_coeff: list of tensors for polynomial interpolation
# Typically stores coefficients for interpolation between t0 and t1
interp_coeff = [
torch.randn(2, 4),
torch.randn(2, 4),
torch.randn(2, 4),
]
ARGS = {
'y1': y1,
'f1': f1,
't0': t0,
't1': t1,
'dt': dt,
'interp_coeff': interp_coeff,
}
- 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 _RungeKuttaState — 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
|
| _VCABMState |
Ran ran on a synthesized input · constructed an object; no result was computed |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("4b236303800173d5") How it ranRan 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, _VCABMState: 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 collections
torch.manual_seed(0)
class _VCABMState(collections.namedtuple('_VCABMState', 'y_n, prev_f, prev_t, next_t, phi, order')):
"""Saved state of the variable step size Adams-Bashforth-Moulton solver as described in
Solving Ordinary Differential Equations I - Nonstiff Problems III.5
by Ernst Hairer, Gerhard Wanner, and Syvert P Norsett.
"""
pass
# Construct arguments for _VCABMState
ARGS = {
'y_n': torch.randn(2, 4), # batch_size=2, state_dim=4
'prev_f': torch.randn(2, 4), # previous function evaluation
'prev_t': torch.tensor(0.0), # previous time step
'next_t': torch.tensor(0.1), # next time step
'phi': [torch.randn(2, 4) for _ in range(3)], # list of phi coefficients for Adams-Bashforth-Moulton
'order': 2 # integration order
}
- 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 _VCABMState — 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
|
| _check_inputs |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("ea3c58d4e24eebb6") How it ranRan 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
torch.manual_seed(0)
def dummy_func(t, y):
"""A simple ODE function that returns dy/dt"""
if isinstance(y, tuple):
return tuple(torch.zeros_like(y_) for y_ in y)
else:
return torch.zeros_like(y)
# Create initial state as a tensor
y0_tensor = torch.randn(2, 4, dtype=torch.float32)
# Create time points (increasing, so no reversal needed)
t = torch.linspace(0, 1, 5, dtype=torch.float32)
ARGS = {
'func': dummy_func,
'y0': y0_tensor,
't': t
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — 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
|
| _check_inputs |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("2224684f11a7a3c9") How it ranRan 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
torch.manual_seed(0)
# Define a simple ODE function that takes (t, y) and returns dy/dt
def ode_func(t, y):
# y is a tensor, return its negative (simple decay)
return -y
# Create initial condition as a single tensor
y0_tensor = torch.randn(2, 4, dtype=torch.float32)
# Create time points (increasing order, small values)
t = torch.tensor([0.0, 0.1, 0.2, 0.3], dtype=torch.float32)
ARGS = {
"func": ode_func,
"y0": y0_tensor,
"t": t
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — 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
|
| _compute_error_ratio |
Ran ran; our contract draft was wrong, not the code |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("8b87a183c9dbf249") How it ranRan 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 float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create small tensors for y0 and y1
y0 = [torch.randn(2, 4), torch.randn(2, 4)]
y1 = [torch.randn(2, 4), torch.randn(2, 4)]
# Create error_estimate as a tuple of tensors
error_estimate = (torch.randn(2, 4), torch.randn(2, 4))
# Create rtol and atol - can be scalars or iterables
rtol = [0.1, 0.1]
atol = [1e-3, 1e-3]
ARGS = {
"error_estimate": error_estimate,
"error_tol": None,
"rtol": rtol,
"atol": atol,
"y0": y0,
"y1": y1,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _convert_to_tensor |
Ran ran; our contract draft was wrong, not the code |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("baa65f15f31a9777") How it ranRan 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
torch.manual_seed(0)
ARGS = {
"a": [1.0, 2.0, 3.0, 4.0],
"dtype": torch.float32,
"device": torch.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 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
|
| _decreasing |
Ran ran, violated the contract we drafted |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("ec95d60f4289b25e") How it ranRan 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 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# The function _decreasing takes parameter 't' and checks if each element
# is strictly less than the previous element (i.e., the sequence is decreasing)
# It uses indexing t[1:] and t[:-1], and calls .all() on a boolean tensor
# So 't' should be a torch tensor
# Create a decreasing tensor
t = torch.tensor([5.0, 4.0, 3.0, 2.0, 1.0])
ARGS = {
"t": t
}
- 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 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
|
| _decreasing |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("aef26a4386aa599b") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The function _decreasing takes a parameter t and calls .item() on t[1] and t[0]
# This means t should be indexable and contain elements with .item() methods
# Tensors satisfy this requirement
t = torch.tensor([5.0, 3.0])
ARGS = {
"t": t
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _has_converged |
Ran ran, violated the contract we drafted |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("80aaab169a92f738") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The function expects:
# - y0: an iterable of tensors
# - y1: an iterable of tensors (same length as y0)
# - rtol: a float (relative tolerance)
# - atol: a float (absolute tolerance)
# Create small tensors with distinct shapes to probe dimensions
y0_tensor1 = torch.randn(2, 4)
y0_tensor2 = torch.randn(3, 5)
y1_tensor1 = y0_tensor1 + torch.randn(2, 4) * 0.01 # Small perturbation
y1_tensor2 = y0_tensor2 + torch.randn(3, 5) * 0.01 # Small perturbation
ARGS = {
"y0": [y0_tensor1, y0_tensor2],
"y1": [y1_tensor1, y1_tensor2],
"rtol": 0.1,
"atol": 0.01
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _interp_coeff_tsit5 |
Ran ran, honoured the contract we drafted |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("a80bde1c9ec425d6") How it ranRan 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 numpy as np
# Define arguments for _interp_coeff_tsit5
# The function takes three scalar arguments: t0, dt, and eval_t
# These are used to compute normalized time t and then interpolation coefficients
t0 = 0.0
dt = 0.1
eval_t = 0.05
ARGS = {
"t0": t0,
"dt": dt,
"eval_t": eval_t,
}
- 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 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
|
| _interp_eval_tsit5 |
Ran ran; our contract draft was wrong, not the code |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("69c9ce066153b90b") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Analyzing _interp_eval_tsit5:
# - t0: float, time at start
# - t1: float, time at end
# - k: tuple of tuples, where each inner tuple contains tensors (k_[0] is accessed)
# - eval_t: float, evaluation time
#
# The function:
# 1. Computes dt = t1 - t0
# 2. Extracts y0 from k (first element of each inner tuple)
# 3. Calls _interp_coeff_tsit5 which does arithmetic on floats
# 4. Calls _scaled_dot_product with dt (scale), interp_coeff list, and k_ (tuple from k)
# 5. _scaled_dot_product multiplies scale * x * y for pairs from two lists
# where x comes from interp_coeff (floats) and y comes from k_ (tuples of tensors)
# Create small tensors for the state vectors
# k should be a tuple of tuples, where each inner tuple represents derivatives/coefficients
# For a system with 2 state variables, we'd have k with 2 inner tuples
# Each inner tuple should have multiple elements (k_[0] is accessed, and then k_ is zipped with interp_coeff)
# Let's create a setup with 2 state dimensions
state_dim = 2
tensor_dim = 4
# Create k as a tuple of tuples
# Each inner tuple has 7 elements (one for each b1-b7 coefficient)
k_tuple_1 = tuple(torch.randn(tensor_dim) for _ in range(7))
k_tuple_2 = tuple(torch.randn(tensor_dim) for _ in range(7))
k = (k_tuple_1, k_tuple_2)
# Time parameters
t0 = 0.0
t1 = 1.0
eval_t = 0.5
ARGS = {
"t0": t0,
"t1": t1,
"k": k,
"eval_t": eval_t,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _is_finite |
Ran ran; our contract draft was wrong, not the code |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("443e9b25ad3ae079") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The function _is_finite checks if a tensor contains any inf or nan values
# It takes a single parameter: tensor
# We need to construct a valid tensor argument
# Create a small tensor with finite values
tensor = torch.randn(2, 4)
ARGS = {
"tensor": tensor
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _is_iterable |
Ran ran, violated the contract we drafted |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("9d72df2efb3a66fe") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Test case 1: list (iterable)
inputs_list = [1, 2, 3, 4]
# Test case 2: string (iterable)
inputs_string = "hello"
# Test case 3: tensor (iterable)
inputs_tensor = torch.randn(2, 4)
# Test case 4: dict (iterable)
inputs_dict = {"a": 1, "b": 2}
# Test case 5: tuple (iterable)
inputs_tuple = (1, 2, 3)
# Test case 6: range (iterable)
inputs_range = range(5)
# Test case 7: int (not iterable)
inputs_int = 42
# Test case 8: float (not iterable)
inputs_float = 3.14
# Test case 9: None (not iterable)
inputs_none = None
# We'll use one representative case for the ARGS
# The function takes 'inputs' as its only parameter
ARGS = {
"inputs": [1, 2, 3, 4]
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _norm |
Ran ran; our contract draft was wrong, not the code |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("c3ee29e30b47fb06") How it ranRan 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 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
torch.manual_seed(0)
# Test case 1: single tensor
x_tensor = torch.randn(2, 4)
# Test case 2: list of tensors
x_list = [torch.randn(2, 4), torch.randn(3, 5)]
# We'll use the tensor case for ARGS
ARGS = {
"x": x_tensor
}
- 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 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
|
| _possibly_nonzero |
Ran ran, violated the contract we drafted |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("285104682369ab82") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
ARGS = {
"x": torch.tensor([1.0, 2.0, 3.0, 4.0])
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _runge_kutta_step |
Ran ran; our contract draft was wrong, not the code |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("2a9f0b547af9d443") How it ranRan 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
torch.manual_seed(0)
# Define a minimal Butcher tableau class with required attributes
class ButcherTableau:
def __init__(self):
self.alpha = [0.0, 0.5, 1.0] # Stage time coefficients
self.beta = [
[], # First stage (empty, no previous stages)
[0.5], # Second stage
[0.0, 1.0] # Third stage
]
self.c_sol = [1/6, 2/3, 1/6] # Solution weights
self.c_error = [1/6 - 1/8, 2/3 - 1/3, 1/6 - 1/24] # Error weights
# Define a simple function that takes (t, y) and returns derivatives
def simple_func(t, y):
"""Returns time derivatives for each component in y."""
# y is a tuple of tensors, return same structure
return tuple(torch.ones_like(y_i) for y_i in y)
# Create initial state y0 as a tuple of tensors (batch_size=2, feature_dim=4)
y0 = (
torch.randn(2, 4),
torch.randn(2, 4)
)
# Create initial derivative f0 (same shape as y0)
f0 = (
torch.randn(2, 4),
torch.randn(2, 4)
)
# Create time parameters
t0 = torch.tensor(0.0, dtype=torch.float64)
dt = torch.tensor(0.1, dtype=torch.float64)
# Create tableau
tableau = ButcherTableau()
ARGS = {
"func": simple_func,
"y0": y0,
"f0": f0,
"t0": t0,
"dt": dt,
"tableau": tableau
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — 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
|
| _scaled_dot_product |
Ran ran on a synthesized input |
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py code served (permissive licence) · get_code("de5906cda333c484") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The function takes:
# - scale: a scalar multiplier
# - xs: a list of tensors (or values)
# - ys: a list of tensors (or values)
# From the function body, we see:
# - scale is multiplied with tensors
# - xs and ys are zipped together
# - each x and y can be a Tensor or a number (0)
# - _possibly_nonzero checks if something is a Tensor or != 0
scale = 2.5
xs = [
torch.randn(2, 4),
torch.randn(2, 4),
0, # zero value to test _possibly_nonzero filtering
]
ys = [
torch.randn(2, 4),
torch.randn(2, 4),
torch.randn(2, 4),
]
ARGS = {
"scale": scale,
"xs": xs,
"ys": ys,
}
- 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
|