| essl |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/smc/src/qhelpers.py code served (permissive licence) · get_code("11b3456d762ba64f") 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 float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a small log-weights array
np.random.seed(0)
lw = np.random.randn(10)
ARGS = {
"lw": lw
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| gaus_log_prob |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/toy/src/hmc.py code served (permissive licence) · get_code("e29f668c27639d43") 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
# Construct arguments for gaus_log_prob
x = np.array([1.0, 2.0, 3.0, 4.0])
mean = np.array([0.5, 1.5, 2.5, 3.5])
sig = np.array([0.5, 0.8, 1.2, 1.5])
ARGS = {
'x': x,
'mean': mean,
'sig': sig
}
- 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
|
| geometric_average |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/toy/src/ais.py code served (permissive licence) · get_code("13d3e55b78d72af6") 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 Gaussian1D. 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
class Gaussian1D:
def __init__(self, mean=None, variance=None, precision=None, precisionxmean=None):
if mean is not None:
self.mean = mean
self.variance = variance
self.precision = 1.0 / variance
self.precisionxmean = mean / variance
else:
self.precision = precision
self.precisionxmean = precisionxmean
self.variance = 1.0 / precision
self.mean = precisionxmean / precision
self.sigma = np.sqrt(self.variance)
def sample(self, no_samples):
return np.random.randn(no_samples) * np.sqrt(self.variance) + self.mean
def logprob(self, x):
return -(0.5 * (np.log(2 * np.pi * self.sigma * self.sigma) + ((x - self.mean) / self.sigma) ** 2))
class MVGaussian:
def __init__(self, mean=None, variance=None, precision=None, precisionxmean=None):
if mean is not None:
self.mean = mean
self.variance = variance
self.precision = np.linalg.inv(self.variance)
self.precisionxmean = np.matmul(self.precision, self.mean)
else:
self.precision = precision
self.precisionxmean = precisionxmean
self.variance = np.linalg.inv(precision)
self.mean = np.matmul(self.variance, precisionxmean)
def sample(self, no_samples):
return np.random.multivariate_normal(self.mean, self.variance, size=(no_samples,))
def logprob(self, x):
from scipy.stats import multivariate_normal
y = multivariate_normal.pdf(x, mean=self.mean, cov=self.variance)
return y
def geometric_average(dist1, dist2, pow1=0.5, pow2=0.5):
precision = dist1.precision * pow1 + dist2.precision * pow2
precisionxmean = dist1.precisionxmean * pow1 + dist2.precisionxmean * pow2
if isinstance(dist1.precision, float) or isinstance(dist1.precision, int):
return Gaussian1D(precision=precision, precisionxmean=precisionxmean)
else:
return MVGaussian(precision=precision, precisionxmean=precisionxmean)
# Create two 1D Gaussian distributions for testing
dist1 = Gaussian1D(mean=0.0, variance=1.0)
dist2 = Gaussian1D(mean=2.0, variance=1.5)
ARGS = {
"dist1": dist1,
"dist2": dist2,
"pow1": 0.5,
"pow2": 0.5
}
- 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 Gaussian1D — a Gaussian1D output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Gaussian1D 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
|
| leapfrog |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
vmasrani/qpaths_uai_2021/toy/src/hmc.py code served (permissive licence) · get_code("7322057dc47258d9") 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
# Define a simple potential function that returns both value and gradient
def potential_fn(q):
"""
Simple quadratic potential: V(q) = 0.5 * sum(q^2)
Gradient: dV/dq = q
"""
V = 0.5 * np.sum(q**2)
dVdq = np.copy(q)
return V, dVdq
# Set up small numpy arrays for position and momentum
q_init = np.array([1.0, 2.0, 0.5, -1.5], dtype=np.float64)
p_init = np.array([0.1, -0.2, 0.3, 0.05], dtype=np.float64)
# Compute initial gradient
V_init, dVdq_init = potential_fn(q_init)
# Parameters for the integrator
path_len = 1.0
step_size = 0.1
ARGS = {
"q": q_init,
"p": p_init,
"dVdq": dVdq_init,
"potential": potential_fn,
"path_len": path_len,
"step_size": step_size,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| log_f_i_geometric |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/ais/ais.py code served (permissive licence) · get_code("00b910b73a0b26b5") 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, 1) 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)
class MockModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 1)
def log_prior(self, z, use_cuda):
"""Return log prior probability of latent z"""
# Simple mock: sum of squares as log prior
return -0.5 * (z ** 2).sum(dim=-1, keepdim=True)
def log_likelihood(self, z, data):
"""Return log likelihood of data given latent z"""
# Simple mock: pass z through linear layer to get likelihood
batch_size = z.shape[0]
likelihood = self.linear(z)
return likelihood
model = MockModel()
# Latent variable: batch_size=2, latent_dim=4
z = torch.randn(2, 4)
# Data: batch_size=2, data_dim=3
data = torch.randn(2, 3)
# Beta parameter: mixture weight between 0 and 1
beta = 0.7
# Use CUDA flag
use_cuda = False
ARGS = {
"model": model,
"z": z,
"data": data,
"beta": beta,
"use_cuda": use_cuda
}
- 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, 1) — shape (2, 1) 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
|
| log_f_i_qpath |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/ais/ais.py code served (permissive licence) · get_code("4777b5cce48437fa") 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, 1) 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)
class SimpleModel(nn.Module):
"""Minimal model that provides log_prior and log_likelihood methods"""
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 1)
def log_prior(self, z, use_cuda):
"""Return log prior as a tensor"""
# Simple Gaussian prior: -0.5 * sum(z^2)
return -0.5 * torch.sum(z ** 2, dim=-1, keepdim=True)
def log_likelihood(self, z, data):
"""Return log likelihood as a tensor"""
# Simple likelihood based on z and data
# data shape: (2, 3), z shape: (2, 4)
x, y = data
# Project z to match data dimension
pred = self.linear(z) # (2, 1)
# Simple Gaussian likelihood
return -0.5 * torch.sum((y - pred) ** 2, dim=-1, keepdim=True)
model = SimpleModel()
# Create latent variable z: shape (2, 4)
z = torch.randn(2, 4)
# Create data as tuple (x, y)
x = torch.randn(2, 3)
y = torch.randn(2, 1)
data = (x, y)
# Other parameters
beta = 0.5
q = 0.8
use_cuda = False
ARGS = {
"model": model,
"z": z,
"data": data,
"beta": beta,
"q": q,
"use_cuda": use_cuda
}
- 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, 1) — shape (2, 1) 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
|
| log_sum_weighted_exp |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/ais/ais.py code served (permissive licence) · get_code("2fd96fd053ae2bbd") 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)
# Create small tensors for the function parameters
# val1 and val2 should be comparable tensors (same shape)
val1 = torch.randn(2, 4)
val2 = torch.randn(2, 4)
# weight1 and weight2 should be scalars or broadcastable tensors
weight1 = torch.tensor(0.3)
weight2 = torch.tensor(0.7)
ARGS = {
"val1": val1,
"val2": val2,
"weight1": weight1,
"weight2": weight2,
}
- 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
|
| log_sum_weighted_exp |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/smc/src/qhelpers.py code served (permissive licence) · get_code("d53b94e96c4b67fd") 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, 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
# Construct arguments for log_sum_weighted_exp
# The function takes 4 numpy array parameters: val1, val2, weight1, weight2
# It performs element-wise operations, so all should have compatible shapes
val1 = np.array([[1.0, 2.0, 3.0, 4.0],
[0.5, 1.5, 2.5, 3.5]])
val2 = np.array([[0.8, 1.9, 2.8, 3.9],
[0.3, 1.2, 2.1, 3.0]])
weight1 = np.array([[0.6, 0.6, 0.6, 0.6],
[0.6, 0.6, 0.6, 0.6]])
weight2 = np.array([[0.4, 0.4, 0.4, 0.4],
[0.4, 0.4, 0.4, 0.4]])
ARGS = {
'val1': val1,
'val2': val2,
'weight1': weight1,
'weight2': weight2
}
- 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, 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
|
| logpdf_to_qlogpdf |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/smc/src/qhelpers.py code served (permissive licence) · get_code("9176ce140edef3ad") 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, 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
# logpdf_to_qlogpdf takes two parameters:
# 1. logpdf: a numpy array of log probability density values
# 2. q: a scalar parameter (likely a float)
# The function computes: (np.exp((1 - q) * logpdf) - 1) / (1 - q)
# This requires:
# - logpdf to be a numpy array that can be multiplied by a scalar
# - q to be a scalar value (float or int)
# Create a small logpdf array (batch size 2, features 4)
logpdf_value = np.random.randn(2, 4) - 5 # negative values typical for log PDFs
# Create a q parameter (scalar, must not equal 1 to avoid division by zero)
q_value = 0.5
ARGS = {
"logpdf": logpdf_value,
"q": q_value
}
- 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, 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
|
| pmap |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/toy/src/utils.py code served (permissive licence) · get_code("d4624bf8815e34ed") 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 int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from tqdm import tqdm
torch.manual_seed(0)
def simple_function(x):
"""A simple function to parallelize"""
return x * 2
def another_function(item):
"""Another simple function that processes items"""
return item + 10
# Define the ARGS dictionary with all parameters for pmap
ARGS = {
'f': simple_function,
'arr': [1, 2, 3, 4, 5],
'n_jobs': 2,
'notebook': False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- joblib, numpy, torch, tqdm — 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 int — 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
|
| student_moment_average |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/toy/src/ais.py code served (permissive licence) · get_code("edb6b4ae38f4ff33") 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 Student1D. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from scipy import stats
from autograd.scipy import stats as autograd_stats
class Student1D:
def __init__(self, q=None, mean=None, variance=None, precision=None, precisionxmean=None, df=None):
self.df = (3 - q) / (q - 1) if q is not None and q != 1 else df
if self.df is None:
raise ValueError('Please specify q parameter (q!=1) or df (degrees of freedom)')
self.q = q if q is not None else (self.df + 3) / (self.df + 1)
if mean is not None:
self.mean = mean
self.variance = variance
self.precision = 1.0 / variance
self.precisionxmean = mean / variance
elif precisionxmean is not None:
self.precision = precision
self.precisionxmean = precisionxmean
self.variance = 1.0 / precision
self.mean = precisionxmean / precision
else:
self.mean = 0
self.variance = 1
self.precision = 1.0 / variance
self.precisionxmean = mean / variance
self.sigma = np.sqrt(self.variance)
self.student_t = stats.t
self.student_t_autograd = autograd_stats.t
def sample(self, no_samples):
return self.student_t.rvs(self.df, size=no_samples, loc=self.mean, scale=self.sigma)
def logprob(self, x):
return self.student_t_autograd.logpdf(x, self.df, loc=self.mean, scale=self.sigma)
def student_moment_average(dist1, dist2, beta):
pow1 = 1 - beta
pow2 = beta
t_scaling = (dist2.df + 2) / dist2.df
t_mean = pow1 * dist1.mean + pow2 * dist2.mean
t_var = pow1 * dist1.variance + pow2 * dist2.variance + t_scaling * pow1 * pow2 * np.outer(dist2.mean - dist1.mean, dist2.mean - dist1.mean)
return Student1D(df=dist2.df, mean=t_mean, variance=t_var)
# Create two Student1D distributions
dist1 = Student1D(df=5.0, mean=np.array(1.0), variance=np.array(2.0))
dist2 = Student1D(df=8.0, mean=np.array(0.5), variance=np.array(1.5))
# Create beta parameter for mixing
beta = 0.3
ARGS = {
'dist1': dist1,
'dist2': dist2,
'beta': beta
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- autograd, numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Student1D — a Student1D output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Student1D 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
|
| tqdm_joblib |
Ran ran; our contract draft was wrong, not the code |
vmasrani/qpaths_uai_2021/toy/src/utils.py code served (permissive licence) · get_code("fc7032ef481eaeb0") 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 _GeneratorContextManager. 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 contextlib
import joblib
from tqdm import tqdm
# Create a simple tqdm object that the context manager will use
tqdm_obj = tqdm(total=100, desc="Processing")
ARGS = {
"tqdm_object": tqdm_obj
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- joblib, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type _GeneratorContextManager — a _GeneratorContextManager output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a _GeneratorContextManager 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
|
| validate_dataset_path |
Ran ran on a synthesized input |
vmasrani/qpaths_uai_2021/smc/src/assertions.py code served (permissive licence) · get_code("a076b5ac757f4ad0") 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 str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
# Construct a minimal args object
class Args:
def __init__(self):
self.data_dir = '/tmp/test_data/'
ARGS = {'args': 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| hmc |
Not yet run unverified (harvested, no recorded run) |
vmasrani/qpaths_uai_2021/toy/src/hmc.py code served (permissive licence) · get_code("6ab30bbf0cd034ba") How it ran |
| moment_average |
Not yet run unverified (harvested, no recorded run) |
vmasrani/qpaths_uai_2021/toy/src/ais.py code served (permissive licence) · get_code("554153c2f7d049eb") How it ran |