| align |
Ran ran on a synthesized input |
Vrushank264/Handwriting-Generation-using-LSTM/utils.py code served (permissive licence) · get_code("506ea1a5a6aab059") 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 int, shape (12, 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
coords = np.array(([2186, 3950], [2176, 3957], [2175, 3965], [2177, 3977], [2185, 3988], [2197, 4001], [2204, 4011], [2207, 4019], [2206, 4019], [2195, 4022], [2179, 4023], [2164, 4027]))
ARGS = {
"coords": coords
}
- 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 int, shape (12, 2) — shape (12, 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
|
| check_eq |
Ran ran on a synthesized input |
SamuelNguyen1998/Vietnamese_Handwriting_Recognition/src/data_utils.py code served (permissive licence) · get_code("e7917e9b49503948") 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 numpy as np
# Create two identical numpy arrays to test the check_eq function
img = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.int32)
img2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.int32)
ARGS = {
"img": img,
"img2": img2,
}
- 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 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
|
| compute_nll_loss |
Ran ran on a synthesized input |
swechhachoudhary/Handwriting-synthesis/utils/model_utils.py code served (permissive licence) · get_code("c89435a714d679dc") 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 torch.nn as nn
import math
torch.manual_seed(0)
# The function expects:
# - targets: tensor with shape (batch, sequence, 3) where dim 2 has [eos, x1, x2]
# - y_hat: tensor with shape (batch, sequence, 141) where 141 = 1 + 20*6 (split_sizes sum)
# - mask: tensor with shape (batch, sequence) for weighting loss
# - M: integer (default 20, used implicitly in split_sizes)
batch_size = 2
sequence_length = 4
target_dim = 3
y_hat_dim = 1 + 20 * 6 # 141 total
targets = torch.randn(batch_size, sequence_length, target_dim)
# Ensure first column (eos targets) is in [0, 1] for BCE
targets[:, :, 0] = torch.sigmoid(targets[:, :, 0])
y_hat = torch.randn(batch_size, sequence_length, y_hat_dim)
mask = torch.ones(batch_size, sequence_length)
ARGS = {
'targets': targets,
'y_hat': y_hat,
'mask': mask,
'M': 20
}
- 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
|
| cumsum |
Ran ran, honoured the contract we drafted |
grzego/handwriting-generation/generate.py code served (permissive licence) · get_code("9bafc68792a5453a") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned ndarray, ndim 2, dtype family float, shape (3, 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
# Create a small numpy array with at least 3 columns
# The function takes cumsum of first 2 columns and concatenates with remaining columns
points = np.array([
[1.0, 2.0, 5.0, 6.0],
[3.0, 4.0, 7.0, 8.0],
[5.0, 6.0, 9.0, 10.0]
])
ARGS = {
"points": points
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- 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 (3, 4) — shape (3, 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
|
| data_denormalization |
Ran ran on a synthesized input |
swechhachoudhary/Handwriting-synthesis/utils/data_utils.py code served (permissive licence) · get_code("8f5f6f10d9df29f1") 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 3, dtype family float, shape (2, 3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# The function expects:
# - mean: array-like, shape matching data[:, :, 1:]
# - std: array-like, shape matching data[:, :, 1:]
# - data: 3D tensor/array where we modify data[:, :, 1:]
# Create a small 3D data tensor: (batch=2, seq=3, features=4)
# The function modifies data[:, :, 1:] which is (2, 3, 3)
data = torch.randn(2, 3, 4, dtype=torch.float32)
# mean and std should match the shape of data[:, :, 1:]
# which is (2, 3, 3) or can be broadcastable to it
mean = torch.randn(3, dtype=torch.float32) # Will broadcast
std = torch.ones(3, dtype=torch.float32)
ARGS = {
"mean": mean,
"std": std,
"data": data
}
- 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 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 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
|
| encode_ascii |
Ran ran on a synthesized input |
Vrushank264/Handwriting-Generation-using-LSTM/utils.py code served (permissive licence) · get_code("d0ea3aaa2f0cb4d7") 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 int, shape (6,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from collections import defaultdict
alphabet = ['\x00', ' ', '!', '"', '#', "'", '(', ')', ',', '-', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'R', 'S', 'T', 'U', 'V', 'W', 'Y', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
alpha_to_num = defaultdict(int, list(map(reversed, enumerate(alphabet))))
def encode_ascii(ascii_str):
return np.array(list(map(lambda x: alpha_to_num[x], ascii_str)) + [0])
# Setup code to construct valid arguments for encode_ascii
ascii_str = "Hello"
ARGS = {
"ascii_str": ascii_str
}
- 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 int, shape (6,) — shape (6,) 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
|
| entropy_iid |
Ran ran on a synthesized input |
kedartatwawadi/NN_compression/src/data_generation_scripts/generate_lagged_fibonacci.py code served (permissive licence) · get_code("78b673d1702aa8fc") 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
# The function entropy_iid takes a probability value (or array of probabilities)
# and computes the binary entropy in bits.
# It expects prob to be a numeric value or numpy array with values in [0, 1]
# Create a simple probability value (scalar)
prob_scalar = 0.5
# Create a numpy array of probabilities for testing array input
prob_array = np.array([0.2, 0.5, 0.7, 0.9])
ARGS = {
"prob": prob_array
}
- 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
|
| filter_line_strokes_and_transcriptions |
Ran ran on a synthesized input |
AnesBenmerzoug/Handwriting-Model/src/handwriting_generator/utils.py code served (permissive licence) · get_code("316f20cd174551b7") 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.
from rich.progress import track
# Construct valid arguments for filter_line_strokes_and_transcriptions
# Create sample line_strokes dict: maps filenames to lists of strokes (each stroke is list of (x,y) tuples)
line_strokes = {
"file1.txt": [[(0, 0), (1, 1), (2, 2)], [(3, 3), (4, 4)]],
"file2.txt": [[(5, 5), (6, 6)]],
"file3.txt": [[(7, 7), (8, 8), (9, 9)]],
}
# Create sample transcriptions dict: maps filenames to text transcriptions
# Include some files not in line_strokes and vice versa to test filtering
transcriptions = {
"file1.txt": "hello world",
"file2.txt": "test transcription",
"file4.txt": "orphan transcription", # not in line_strokes
}
# file3.txt is in line_strokes but not in transcriptions, so it should be removed
# file4.txt is in transcriptions but not in line_strokes, so it should be removed
show_progress = False
ARGS = {
"line_strokes": line_strokes,
"transcriptions": transcriptions,
"show_progress": show_progress,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- rich — 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
|
| gen_training_sequences |
Ran ran, honoured the contract we drafted |
robertknight/textgen/textgen/__main__.py pointer only (licence: NONE) · get_code("232da28e6492c6fb") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, robertknight/textgen 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. |
| get_pi_idx |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
this paper's copy was not recorded; identical code first harvested from hardmaru/WorldModelsExperiments pointer only; the stored copy get_code serves, from hardmaru/WorldModelsExperiments, is pointer only (licence: NONE) · get_code("7bb85eb640efb52d") How it ranThe body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| labels_to_text |
Ran ran on a synthesized input |
SamuelNguyen1998/Vietnamese_Handwriting_Recognition/src/utils.py code served (permissive licence) · get_code("8a9c5ba6da1be290") 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
torch.manual_seed(0)
# Analyzing the function:
# - labels_to_text takes 'letters' and 'labels'
# - It maps over labels, using each label as an index into letters
# - It returns empty string if index >= len(letters)
# - So 'letters' should be a sequence (list or string)
# - And 'labels' should be an iterable of integers
letters = ['a', 'b', 'c', 'd', 'e']
# Create a small tensor of label indices
labels = torch.tensor([0, 1, 2, 3, 4, 10], dtype=torch.long)
ARGS = {
'letters': letters,
'labels': labels
}
- 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
|
| load_line_strokes |
Ran ran on a synthesized input |
AnesBenmerzoug/Handwriting-Model/src/handwriting_generator/utils.py code served (permissive licence) · get_code("b15244e710c02e4a") 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 dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
import xml.etree.ElementTree as ET
from pathlib import Path
# Create a temporary directory with test XML files
temp_dir = tempfile.TemporaryDirectory()
temp_path = Path(temp_dir.name)
# Create a valid XML file structure matching what the function expects
# The function expects:
# - root[0] to have children at indices 1, 2, 3 with 'x' and 'y' attributes
# - root[1] to contain 'Stroke' elements
# - Each 'Stroke' to contain 'Point' elements with 'x' and 'y' attributes
xml_content = """<?xml version="1.0" encoding="UTF-8"?>
<root>
<BoundingBox>
<dummy/>
<Point x="10" y="20"/>
<Point x="30" y="40"/>
<Point x="50" y="60"/>
</BoundingBox>
<StrokeSet>
<Stroke>
<Point x="15" y="25"/>
<Point x="20" y="30"/>
<Point x="25" y="35"/>
</Stroke>
<Stroke>
<Point x="35" y="45"/>
<Point x="40" y="50"/>
</Stroke>
</StrokeSet>
</root>
"""
# Write test XML files
for i in range(2):
xml_file = temp_path / f"test_stroke_{i}.xml"
xml_file.write_text(xml_content)
ARGS = {
"line_strokes_dir": temp_path,
"show_progress": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- rich — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_transcriptions |
Ran ran on a synthesized input |
AnesBenmerzoug/Handwriting-Model/src/handwriting_generator/utils.py code served (permissive licence) · get_code("1430cb6d9a3f833d") 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 dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
from pathlib import Path
# Create a temporary directory with test .txt files
temp_dir = tempfile.TemporaryDirectory()
ascii_dir = Path(temp_dir.name)
# Create test transcription files
test_file_1 = ascii_dir / "test1.txt"
test_file_1.write_text("""Some header info
CSR: First line of transcription
Second line of transcription
Third line
""")
test_file_2 = ascii_dir / "test2.txt"
test_file_2.write_text("""Another file
CSR: Line one
Line two
Line three
""")
# Create a file that should be skipped
test_file_skip = ascii_dir / "skip_me.txt"
test_file_skip.write_text("""Please enter transcription here
CSR: This should be skipped
""")
ARGS = {
'ascii_dir': ascii_dir,
'show_progress': False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- rich — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| mixture_of_bivariate_normal_nll |
Ran ran on a synthesized input |
Vrushank264/Handwriting-Generation-using-LSTM/functions.py code served (permissive licence) · get_code("0858be3fdf9eb3de") 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 (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Construct valid arguments for mixture_of_bivariate_normal_nll
batch_size = 2
num_mixtures = 4
# data: x and y points, shape (batch_size, 2)
# The function does data.unsqueeze(-2).unbind(-1), so it expects shape (batch, 2)
data = torch.randn(batch_size, 2)
# log_pi: mixture weights, shape (batch_size, num_mixtures)
log_pi = torch.randn(batch_size, num_mixtures)
# myu: means of bivariate normal distribution, shape (batch_size, num_mixtures, 2)
# Contains 2 means: myu1 & myu2
myu = torch.randn(batch_size, num_mixtures, 2)
# log_sigma: log variance of bivariate normal distribution, shape (batch_size, num_mixtures, 2)
# Contains 2 log variances: log_sigma1 & log_sigma2
log_sigma = torch.randn(batch_size, num_mixtures, 2)
# rho: Covariance, shape (batch_size, num_mixtures)
# Should be between -1 and 1 for valid covariance
rho = torch.tanh(torch.randn(batch_size, num_mixtures))
# eps: small constant for numerical stability
eps = 1e-6
ARGS = {
"data": data,
"log_pi": log_pi,
"myu": myu,
"log_sigma": log_sigma,
"rho": rho,
"eps": eps,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| mixture_of_bivariate_normal_sample |
Ran ran on a synthesized input |
Vrushank264/Handwriting-Generation-using-LSTM/functions.py code served (permissive licence) · get_code("de459a9fb9e0a962") 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, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Construct valid arguments for mixture_of_bivariate_normal_sample
# The function samples from a mixture of bivariate normal distributions
# log_pi: log probabilities of mixture components, shape (batch_size, num_components)
log_pi = torch.randn(2, 3) # batch_size=2, num_components=3
# myu: means of the bivariate normal, shape (batch_size, num_components, 2)
myu = torch.randn(2, 3, 2) # batch_size=2, num_components=3, 2D means
# log_sigma: log standard deviations, shape (batch_size, num_components, 2)
log_sigma = torch.randn(2, 3, 2) # batch_size=2, num_components=3, 2D sigmas
# rho: correlation coefficients, shape (batch_size, num_components)
rho = torch.sigmoid(torch.randn(2, 3)) * 0.9 # batch_size=2, num_components=3, values in (0, 1)
# bias: scalar or tensor that adjusts the mixture weights
bias = 0.1
# eps: small constant for numerical stability (optional, has default)
eps = 1e-6
ARGS = {
"log_pi": log_pi,
"myu": myu,
"log_sigma": log_sigma,
"rho": rho,
"bias": bias,
"eps": eps,
}
- 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, 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
|
| path_string_to_stroke |
Ran ran on a synthesized input |
swechhachoudhary/Handwriting-synthesis/app/xml_parser.py code served (permissive licence) · get_code("453cf42813afb445") 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 (7, 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
# Construct a valid path string argument
# The function expects a space-separated string of commands like "M0,0 L10,20 L20,30 M30,40 L40,50 "
# Format: command (M or L) followed by x,y coordinates separated by comma
path_string = "M0,0 L10,20 L20,30 L30,40 M50,50 L60,60 L70,70 "
# str_len parameter - expected stroke length
str_len = 10
# down_sample parameter - boolean flag
down_sample = False
ARGS = {
"path": path_string,
"str_len": str_len,
"down_sample": down_sample
}
- 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 (7, 3) — shape (7, 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
|
| preprocess_batch |
Ran ran on a synthesized input |
Vrushank264/Handwriting-Generation-using-LSTM/data.py code served (permissive licence) · get_code("c794567624eca063") 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 sample strokes: list of tensors with shape (seq_len, 3)
stroke1 = torch.randn(5, 3).float() # 5 points, 3 dimensions
stroke2 = torch.randn(3, 3).float() # 3 points, 3 dimensions
# Create sample sentences: list of tensors with token indices
sentence1 = torch.tensor([1, 2, 3, 4], dtype=torch.long) # 4 tokens
sentence2 = torch.tensor([5, 6], dtype=torch.long) # 2 tokens
# Create batch as list of (stroke, sentence) tuples
batch = [
(stroke1, sentence1),
(stroke2, sentence2)
]
ARGS = {
"batch": batch
}
- 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
|
| recognize_stroke |
Ran ran; our contract draft was wrong, not the code |
KurtAhn/lyrebird/models/kurt.py pointer only (licence: NONE) · get_code("7f57a4dfdc98e7c2") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, KurtAhn/lyrebird 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. |
| sample |
Ran ran; our contract draft was wrong, not the code |
robertknight/textgen/textgen/__main__.py pointer only (licence: NONE) · get_code("bdc663f8a518e964") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, robertknight/textgen 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. |
| sample |
Ran ran, honoured the contract we drafted |
grzego/handwriting-generation/generate.py code served (permissive licence) · get_code("b5136c243f64693e") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) 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
np.random.seed(0)
ARGS = {
'e': 0.3,
'mu1': 1.5,
'mu2': -0.5,
'std1': 2.0,
'std2': 1.5,
'rho': 0.7
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- 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
|
| scale |
Ran ran on a synthesized input |
SamuelNguyen1998/Vietnamese_Handwriting_Recognition/src/data_utils.py code served (permissive licence) · get_code("a43e3c26a372625d") 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 int, shape (32, 48) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from PIL import Image
# Set seed for reproducibility
np.random.seed(0)
# Create a small test image as a numpy array
# Using shape (height, width) = (32, 48) for a small but non-square image
test_img = np.random.randint(0, 256, size=(32, 48), dtype=np.uint8)
ARGS = {
"img": test_img,
"scale_prob": 0.5,
"scale_stdv": 0.01,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL, 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 int, shape (32, 48) — shape (32, 48) 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
|
| skew |
Ran ran on a synthesized input |
Vrushank264/Handwriting-Generation-using-LSTM/utils.py code served (permissive licence) · get_code("57345eef39f87d96") 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 int, shape (12, 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
coords = np.array([[2186, 3950], [2176, 3957], [2175, 3965], [2177, 3977], [2185, 3988], [2197, 4001], [2204, 4011], [2207, 4019], [2206, 4019], [2195, 4022], [2179, 4023], [2164, 4027]])
ARGS = {
"coords": coords,
"degree": 45
}
- 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 int, shape (12, 2) — shape (12, 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
|
| split_strokes |
Ran ran, honoured the contract we drafted |
grzego/handwriting-generation/generate.py code served (permissive licence) · get_code("0ff24ae32bac2d32") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned list. 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
# The function expects points to be an array-like with shape (N, 3)
# where the third column (index 2) contains stroke-end markers (1.0 indicates end of stroke)
# The function splits the points into separate strokes based on these markers
# Create a sample points array with multiple strokes
# Each row is [x, y, stroke_end_flag]
# stroke_end_flag = 1.0 means this point is the end of a stroke
points = [
[0.1, 0.2, 0.0], # stroke 1, point 1
[0.3, 0.4, 0.0], # stroke 1, point 2
[0.5, 0.6, 1.0], # stroke 1, point 3 (end of stroke)
[1.0, 1.1, 0.0], # stroke 2, point 1
[1.2, 1.3, 1.0], # stroke 2, point 2 (end of stroke)
[2.0, 2.1, 0.0], # stroke 3, point 1
[2.2, 2.3, 0.0], # stroke 3, point 2
[2.4, 2.5, 0.0], # stroke 3, point 3
[2.6, 2.7, 1.0], # stroke 3, point 4 (end of stroke)
]
ARGS = {
'points': points
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list — a list 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
|
| stable_softmax |
Ran ran on a synthesized input |
swechhachoudhary/Handwriting-synthesis/utils/model_utils.py code served (permissive licence) · get_code("40eb6d67a6e160c6") 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 3, dtype family float, shape (2, 4, 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
torch.manual_seed(0)
# Create a small tensor for testing stable_softmax
# The function uses dim=2 by default, so we need at least 3 dimensions
# Shape: (batch=2, feature=4, classes=3)
X = torch.randn(2, 4, 3)
ARGS = {
"X": X,
"dim": 2
}
- 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 3, dtype family float, shape (2, 4, 3) — shape (2, 4, 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
|
| svg_xml_parser |
Ran ran on a synthesized input |
swechhachoudhary/Handwriting-synthesis/app/xml_parser.py code served (permissive licence) · get_code("f84bc9f82b0a9658") 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 tempfile
import os
from xml.dom import minidom
# Create a temporary SVG file with valid path data
temp_dir = tempfile.mkdtemp()
svg_path = os.path.join(temp_dir, 'writing_8.svg')
# Create a minimal valid SVG with a path element
svg_content = '''<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">
<path d="M 10 10 L 20 20 L 30 30 L 40 40 "/>
</svg>'''
with open(svg_path, 'w') as f:
f.write(svg_content)
ARGS = {
'svg_path': svg_path
}
- 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 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
|
| text_to_labels |
Ran ran on a synthesized input |
SamuelNguyen1998/Vietnamese_Handwriting_Recognition/src/utils.py code served (permissive licence) · get_code("0c9fb7323dbd8b8f") 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
torch.manual_seed(0)
# The function text_to_labels takes:
# - letters: a sequence that supports .index() method
# - text: an iterable of characters to look up in letters
letters = "abcdefghijklmnopqrstuvwxyz"
text = "hello"
ARGS = {
"letters": letters,
"text": text
}
- 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 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
|
| train_offset_normalization |
Ran ran on a synthesized input |
swechhachoudhary/Handwriting-synthesis/utils/data_utils.py code served (permissive licence) · get_code("e25dad2e1379fe88") 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
import numpy as np
torch.manual_seed(0)
# The function expects a numpy array with shape (batch, sequence, features)
# where it normalizes over all but the last dimension, specifically columns 1: (skipping column 0)
# Let's create a small sample dataset with shape (2, 3, 4)
# - batch size: 2
# - sequence length: 3
# - features: 4 (first column is kept as-is, columns 1:4 are normalized)
data = np.random.randn(2, 3, 4).astype(np.float32)
ARGS = {
"data": data
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| valid_offset_normalization |
Ran ran on a synthesized input |
swechhachoudhary/Handwriting-synthesis/utils/data_utils.py code served (permissive licence) · get_code("3b394d43bf805dbc") 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 3, dtype family float, shape (2, 3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Create a small 3D tensor: (batch=2, sequence=3, features=4)
# The function operates on data[:, :, 1:], so we need at least 2 features
# to have something left after slicing from index 1
data = torch.randn(2, 3, 4, dtype=torch.float32)
# Create mean and std tensors that match the feature dimension after slicing
# data[:, :, 1:] has shape (2, 3, 3), so mean and std should be broadcastable to (3,)
mean = torch.randn(3, dtype=torch.float32)
std = torch.randn(3, dtype=torch.float32).abs() + 0.1 # Ensure non-zero for division
ARGS = {
"mean": mean,
"std": std,
"data": data
}
- 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 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 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
|
| vocab_decode |
Ran ran on a synthesized input |
kedartatwawadi/NN_compression/misc_code/10_char_rnn_gist.py code served (permissive licence) · get_code("cd578a493dc93a37") 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
import numpy as np
torch.manual_seed(0)
# The function vocab_decode takes:
# - array: a sequence of integers (1-indexed)
# - vocab: a sequence/list that can be indexed
# It decodes the array by looking up each element (minus 1) in vocab
# Create a small vocabulary
vocab = ['a', 'b', 'c', 'd', 'e']
# Create an array of 1-indexed values pointing into the vocab
# Valid indices are 1 through len(vocab), so values should be in [1, 2, 3, 4, 5]
array = [1, 2, 3, 2, 1]
ARGS = {
'array': array,
'vocab': vocab
}
- 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 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
|
| vocab_decode |
Ran ran on a synthesized input |
kedartatwawadi/NN_compression/misc_code/13_char_rnn_gist.py code served (permissive licence) · get_code("2d6be2ab08f58d21") 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
import numpy as np
torch.manual_seed(0)
# vocab_decode takes an array of indices and a vocab dict/list
# It iterates through array and looks up each index in vocab
# vocab can be a list or dict where indices map to characters/strings
# Create a small vocab - mapping indices to characters
vocab = {
0: 'a',
1: 'b',
2: 'c',
3: 'd'
}
# Create an array of indices to decode
array = [0, 1, 2, 3, 1, 0]
ARGS = {
'array': array,
'vocab': vocab
}
- 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 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
|
| vocab_encode |
Ran ran on a synthesized input |
kedartatwawadi/NN_compression/misc_code/10_char_rnn_gist.py code served (permissive licence) · get_code("3eb3077a0bd2904e") 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
torch.manual_seed(0)
# The function vocab_encode expects:
# - text: an iterable of characters/strings
# - vocab: a list-like object that supports the .index() method and membership testing with 'in'
text = "hello"
vocab = ['h', 'e', 'l', 'o', 'w', 'r', 'd']
ARGS = {
"text": text,
"vocab": vocab
}
- 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 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
|
| create_rnn |
Not yet run unverified (harvested, no recorded run) |
kedartatwawadi/NN_compression/misc_code/10_char_rnn_gist.py code served (permissive licence) · get_code("510351eab5eaed0f") How it ran |
| create_rnn |
Not yet run unverified (harvested, no recorded run) |
kedartatwawadi/NN_compression/misc_code/11_char_rnn_gist.py code served (permissive licence) · get_code("59b0e285ea9b27a7") How it ran |
| create_rnn |
Not yet run unverified (harvested, no recorded run) |
kedartatwawadi/NN_compression/misc_code/12_char_rnn_gist.py code served (permissive licence) · get_code("46bd9f125794535d") How it ran |
| create_rnn |
Not yet run unverified (harvested, no recorded run) |
kedartatwawadi/NN_compression/misc_code/15_char_rnn_gist.py code served (permissive licence) · get_code("c642e923cb957119") How it ran |
| ctc_lambda_func |
Not yet run unverified (harvested, no recorded run) |
SamuelNguyen1998/Vietnamese_Handwriting_Recognition/src/loss.py code served (permissive licence) · get_code("891407c075760cb4") How it ran |
| get_logger |
Not yet run unverified (harvested, no recorded run) |
SamuelNguyen1998/Vietnamese_Handwriting_Recognition/src/log.py code served (permissive licence) · get_code("ce47adec051d5431") How it ran |