| angle_between_points |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/worlds/anglecalc2.py code served (permissive licence) · get_code("26b80952ee33e134") 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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import math
DEGREES_360 = 2 * math.pi
def fix_angular_value(angle):
while angle >= DEGREES_360:
angle -= DEGREES_360
while angle < 0:
angle += DEGREES_360
return angle
def atanxy(x, y):
return math.atan2(y, x)
def angle_between_points(source_point, target_point):
source_x, source_y = source_point
target_x, target_y = target_point
dx = target_x - source_x
dy = target_y - source_y
return fix_angular_value(atanxy(dx, dy))
# Setup valid arguments
source_point = (1.0, 2.0)
target_point = (4.0, 6.0)
ARGS = {
"source_point": source_point,
"target_point": target_point
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| atanxy |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/worlds/anglecalc2.py code served (permissive licence) · get_code("380f932345a21f50") 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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import math
ARGS = {
"x": 3.0,
"y": 4.0,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| dkf |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/worlds/worlds.py code served (permissive licence) · get_code("1e0a64d14bc2f4bf") 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 numpy as np
import scipy.linalg
# Construct valid arguments for dkf function
# The function performs discrete algebraic Riccati equation solving and Kalman filtering
# Create a discrete-time system: A is the state transition matrix (n x n)
n = 4 # state dimension
A = np.array([
[0.9, 0.1, 0.0, 0.0],
[0.0, 0.8, 0.1, 0.0],
[0.0, 0.0, 0.7, 0.1],
[0.0, 0.0, 0.0, 0.6]
], dtype=float)
# C is the measurement matrix (m x n), where m is measurement dimension
m = 3 # measurement dimension (distinct from n)
C = np.array([
[1.0, 0.5, 0.0, 0.0],
[0.0, 1.0, 0.5, 0.0],
[0.0, 0.0, 1.0, 0.5]
], dtype=float)
# Q is the process noise covariance (n x n)
Q = np.eye(n, dtype=float)
# R is the measurement noise covariance (m x m)
R = np.eye(m, dtype=float)
ARGS = {
"A": A,
"C": C,
"Q": Q,
"R": R
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| dlqr |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/worlds/worlds.py code served (permissive licence) · get_code("7793f905be22ce49") 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 numpy as np
import scipy
# Set random seed for reproducibility
np.random.seed(0)
# Define small matrices for a discrete LQR problem
# State dimension: 3, Control dimension: 2
# x[k+1] = A x[k] + B u[k]
# State transition matrix (3x3)
A = np.array([[1.1, 0.1, 0.0],
[0.0, 0.9, 0.2],
[0.1, 0.0, 1.0]], dtype=float)
# Control input matrix (3x2)
B = np.array([[1.0, 0.0],
[0.5, 1.0],
[0.0, 0.5]], dtype=float)
# State cost matrix (3x3) - positive definite
Q = np.array([[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]], dtype=float)
# Control cost matrix (2x2) - positive definite
R = np.array([[0.1, 0.0],
[0.0, 0.1]], dtype=float)
ARGS = {
"A": A,
"B": B,
"Q": Q,
"R": R
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| error_mean |
Ran ran on a synthesized input |
forgi86/dynonet/src/dynonet/metrics.py code served (permissive licence) · get_code("95b9ba9c82e2d714") 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 ndarray, ndim 1, dtype family float, shape (3,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create small numpy arrays for testing
np.random.seed(0)
# y_true: 2D array with shape (time_steps, channels)
# time_axis=0 means we compute mean across time for each channel
y_true = np.random.randn(5, 3) # 5 time steps, 3 channels
# y_pred: must be compatible with y_true (same shape)
y_pred = np.random.randn(5, 3)
# time_axis: which axis represents time
time_axis = 0
ARGS = {
"y_true": y_true,
"y_pred": y_pred,
"time_axis": time_axis,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family float, shape (3,) — shape (3,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| error_nrmse |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/torchid/metrics.py code served (permissive licence) · get_code("141779fa702c2609") 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 ndarray, ndim 1, dtype family float, shape (3,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Set random seed for reproducibility
np.random.seed(0)
# Create small sample arrays
# y_true and y_pred must be at least 2D
# Using shape (time_steps=5, channels=3) with time_axis=0
y_true = np.random.randn(5, 3).astype(np.float32)
y_pred = y_true + np.random.randn(5, 3) * 0.1 # Add small noise
time_axis = 0
ARGS = {
"y_true": y_true,
"y_pred": y_pred,
"time_axis": time_axis,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family float, shape (3,) — shape (3,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| error_rmse |
Ran ran on a synthesized input |
forgi86/dynonet/src/dynonet/metrics.py code served (permissive licence) · get_code("a02d690c3488ab33") 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 ndarray, ndim 1, dtype family float, shape (3,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create simple test data
np.random.seed(0)
# y_true and y_pred need to be at least 2D
# Using shape (5, 3) - 5 time steps, 3 channels
y_true = np.random.randn(5, 3).astype(np.float32)
y_pred = np.random.randn(5, 3).astype(np.float32)
# time_axis specifies which axis represents time (default 0)
time_axis = 0
ARGS = {
'y_true': y_true,
'y_pred': y_pred,
'time_axis': time_axis
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family float, shape (3,) — shape (3,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| extract_weights |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/diffutil/jacobian.py code served (permissive licence) · get_code("40cb6c0947e35170") 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
from torch import nn, Tensor
from typing import List, Tuple, Dict, Union, Callable
torch.manual_seed(0)
# Create a simple nn.Module with some parameters
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
mod = SimpleModel()
ARGS = {
"mod": mod
}
- 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
|
| fix_angular_value |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/worlds/anglecalc2.py code served (permissive licence) · get_code("c17836fe2e4d4cfc") 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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import math
DEGREES_360 = 2 * math.pi
def fix_angular_value(angle):
while angle >= DEGREES_360:
angle -= DEGREES_360
while angle < 0:
angle += DEGREES_360
return angle
# Test cases with various angle values
ARGS = {
"angle": 8.5 # A value greater than 2π (approximately 6.28), will be normalized
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| istuple |
Ran ran on a synthesized input |
forgi86/dynonet/test_code/linearsiso_module_example.py code served (permissive licence) · get_code("8a7aa318d132c7d4") 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
import torch.nn as nn
torch.manual_seed(0)
# Test case 1: Regular Python tuple
obj1 = (1, 2, 3)
# Test case 2: torch.return_types object
# Create a return_types object by using a torch function that returns one
obj2 = torch.max(torch.tensor([1.0, 2.0, 3.0]), dim=0)
# Test case 3: Non-tuple object for contrast
obj3 = [1, 2, 3]
ARGS = {
"obj": obj1
}
- 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
|
| jvp_diff |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/diffutil/products.py code served (permissive licence) · get_code("e4c9550af0b40a6e") 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)
# Create a simple computational graph where:
# y = f(x) for some differentiable function
# We need y, x, and v (a tangent vector)
# x: input tensor - small, 2D for simplicity
x = torch.tensor([[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]], requires_grad=True)
# Define a simple function: y = x^2 (element-wise)
y = x ** 2
# v: tangent vector with same shape as y
v = torch.tensor([[1.0, 0.0, 0.0, 0.0],
[0.0, 1.0, 0.0, 0.0]], requires_grad=True)
ARGS = {
"y": y,
"x": x,
"v": v,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| lfilter_mimo_channels_first |
Ran ran on a synthesized input |
forgi86/dynonet/src/dynonet/filtering.py code served (permissive licence) · get_code("e153a6af140a7af3") 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 ndarray, ndim 3, dtype family float, shape (2, 4, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import scipy.signal
# Parameters for lfilter_mimo_channels_first
batch_size = 2
in_ch = 3
out_ch = 4
seq_len = 5
filter_len = 2
# Create filter coefficients b and a
# b shape: (out_ch, in_ch, filter_len)
# a shape: (out_ch, in_ch, filter_len)
b = np.random.randn(out_ch, in_ch, filter_len).astype(np.float32)
a = np.random.randn(out_ch, in_ch, filter_len).astype(np.float32)
a[:, :, 0] = 1.0 # Ensure first coefficient is non-zero for stability
# Create input signal u_in
# u_in shape: (batch_size, in_ch, seq_len)
u_in = np.random.randn(batch_size, in_ch, seq_len).astype(np.float32)
ARGS = {
"b": b,
"a": a,
"u_in": u_in,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 3, dtype family float, shape (2, 4, 5) — shape (2, 4, 5) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| lfilter_mimo_components_channels_first |
Ran ran on a synthesized input |
forgi86/dynonet/src/dynonet/filtering.py code served (permissive licence) · get_code("50f4d3f1a228fe87") 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 ndarray, ndim 4, dtype family float, shape (2, 4, 3, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import scipy.signal
# Set seed for reproducibility
np.random.seed(0)
# Define dimensions
batch_size = 2
in_ch = 3
out_ch = 4
seq_len = 5
filter_order = 2
# Create b coefficients: shape (out_ch, in_ch, filter_order)
b = np.random.randn(out_ch, in_ch, filter_order).astype(np.float64)
# Create a coefficients: shape (out_ch, in_ch, filter_order)
# Make sure a is not all zeros to avoid division issues
a = np.random.randn(out_ch, in_ch, filter_order).astype(np.float64)
a = a + 1.0 # Ensure non-zero values
# Create input signal: shape (batch_size, in_ch, seq_len)
u_in = np.random.randn(batch_size, in_ch, seq_len).astype(np.float64)
ARGS = {
"b": b,
"a": a,
"u_in": u_in,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 4, dtype family float, shape (2, 4, 3, 5) — shape (2, 4, 3, 5) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| lfiltic_vec |
Ran ran on a synthesized input |
forgi86/dynonet/src/dynonet/filtering.py code served (permissive licence) · get_code("435757878f8b6d61") 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 ndarray, ndim 2, dtype family float, shape (2, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Small test case for lfiltic_vec
# The function processes batches of initial conditions for IIR filters
# Create filter coefficients (simple 2nd order filter)
b = np.array([1.0, 0.5, 0.25]) # numerator coefficients, length 3
a = np.array([1.0, -0.3, 0.1]) # denominator coefficients, length 3
# Create batch of initial output conditions
# Batch size = 2, needs at least N=len(a)-1=2 values per batch
y = np.array([[1.0, 0.5, 0.2],
[0.3, 0.4, 0.1]], dtype=np.float64)
# Create batch of initial input conditions (optional)
# Batch size = 2, M=len(b)-1=2 values per batch
x = np.array([[2.0, 1.0],
[0.5, 1.5]], dtype=np.float64)
ARGS = {
'b': b,
'a': a,
'y': y,
'x': x,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (2, 2) — shape (2, 2) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| parameter_jacobian |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/diffutil/jacobian.py code served (permissive licence) · get_code("cd0cf8e1e78444fa") 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, 201) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from torch import nn
torch.manual_seed(0)
# Create a simple model with nested parameters
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.input_size = 4
self.linear1 = nn.Linear(4, 8)
self.linear2 = nn.Linear(8, 3)
def forward(self, x):
x = self.linear1(x)
x = torch.relu(x)
x = self.linear2(x)
return x
# Create model instance
model = SimpleModel()
# Create 2D input: batch_size=2, input_dim=4
input_2d = torch.randn(2, 4)
# Create 3D input: batch_size=2, seq_len=3, input_dim=4
input_3d = torch.randn(2, 3, 4)
ARGS = {
'model': model,
'input': input_2d,
'vectorize': True,
'flatten': True,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (2, 201) — shape (2, 201) 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
|
| r_squared |
Ran ran on a synthesized input |
forgi86/dynonet/src/dynonet/metrics.py code served (permissive licence) · get_code("29d31ec5ffa18d2c") 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 ndarray, 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 numpy as np
# Set random seed for reproducibility
np.random.seed(0)
# Create small test arrays
# y_true: shape (10, 4) - 10 time steps, 4 channels
y_true = np.random.randn(10, 4)
# y_pred: same shape as y_true
y_pred = y_true + np.random.randn(10, 4) * 0.1
# time_axis: which axis represents time
time_axis = 0
ARGS = {
"y_true": y_true,
"y_pred": y_pred,
"time_axis": time_axis,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family float, shape (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
|
| solve |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/worlds/worlds.py code served (permissive licence) · get_code("0e8cbe19b00bf520") 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 ndarray, ndim 2, dtype family float, shape (1, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import scipy
from functools import partial
torch = None # Not needed for this function
# Define a simple function that acts as the ODE system
def ode_function(t, state, input_value=None):
"""Simple ODE: dy/dt = -y + input_value"""
return -state + input_value
# Create initial state - should be a list/array where [0] is the initial condition
# The function expects initial_state[0] to be passed to solve_ivp
initial_state = [np.array([1.0, 2.0, 3.0, 4.0])]
# Create input value - will be passed to the ODE function
input_value = np.array([0.5, 0.5, 0.5, 0.5])
# Time step
dt = 0.001
ARGS = {
"f": ode_function,
"initial_state": initial_state,
"input_value": input_value,
"dt": dt
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (1, 4) — shape (1, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| vjp |
Ran ran on a synthesized input |
forgi86/rnn-adaptation/diffutil/products.py code served (permissive licence) · get_code("8fa24d073ea3ade3") 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 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create a simple function that we'll differentiate
# Let's say y = x^2, so dy/dx = 2x
x = torch.tensor([[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]], requires_grad=True)
# Compute y = x^2 (element-wise)
y = x ** 2
# Create a vector v with same shape as y for the vjp
v = torch.ones_like(y)
ARGS = {
"y": y,
"x": x,
"v": v
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 3, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| jvp |
Not yet run unverified (harvested, no recorded run) |
forgi86/rnn-adaptation/diffutil/products.py code served (permissive licence) · get_code("50a5b17ae068ea4e") How it ran |