SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1308.0850 · 2013

Generating Sequences With Recurrent Neural Networks

arXiv · PDF · Open in the Atlas

Code that ran

31 of 37 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 4 honoured the contract we drafted, 0 violated it and 24 have no contract verdict; 3 failures of our instrument; 6 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1308.0850.json · badge: /api/ran/1308.0850.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
swechhachoudhary/Handwriting-synthesis community (classifier label)
classifier basis not recorded on the link
7 ran · 0 no recorded run
Vrushank264/Handwriting-Generation-using-LSTM community (classifier label)
classifier basis not recorded on the link
6 ran · 0 no recorded run
kedartatwawadi/NN_compression community (classifier label)
classifier basis not recorded on the link
4 ran · 4 no recorded run
SamuelNguyen1998/Vietnamese_Handwriting_Recognition community (classifier label)
classifier basis not recorded on the link
4 ran · 2 no recorded run
grzego/handwriting-generation reimplementation (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
AnesBenmerzoug/Handwriting-Model community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
robertknight/textgen reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
KurtAhn/lyrebird reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
FunctionStatusWhere it lives
align Ran
ran on a synthesized input
Vrushank264/Handwriting-Generation-using-LSTM/utils.py
code served (permissive licence) · get_code("506ea1a5a6aab059")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 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 ran

Ran 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

The 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 ran

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

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 ran

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

import torch

torch.manual_seed(0)

# 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 ran

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

import 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 ran

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

import 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 ran

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

import torch
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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

The 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 ran

The 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 ran

Ran 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 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 ran

Ran 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 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 ran

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

import tempfile
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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 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 ran

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

import torch
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 ran

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

import torch
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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family 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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

Also present in other papers' code

Of 37 samples lifted from this paper's linked repositories, 37 carry a function identity and 0 do not. Of the 36 distinct functions with an identity, 4 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 4 later) and 32 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
get_pi_idx 3 other papers
3 later
1611.03068 (2016-11)
Incremental Sequence Learning
1811.00145 (2018-11)
Scalable End-to-End Autonomous Vehicle Testing via Rare-event Simulation
cumsum 1 other paper
1 later
2307.01946 (2023-07)
ECG-Image-Kit: A Synthetic Image Generation Toolbox to Facilitate Deep Learning-Based Electrocardiogram Digitization
sample 1 other paper
1 later
2307.01946 (2023-07)
ECG-Image-Kit: A Synthetic Image Generation Toolbox to Facilitate Deep Learning-Based Electrocardiogram Digitization
split_strokes 1 other paper
1 later
2307.01946 (2023-07)
ECG-Image-Kit: A Synthetic Image Generation Toolbox to Facilitate Deep Learning-Based Electrocardiogram Digitization

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

Repositories linked to this paper

More are linked than shown here.

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

Abstract

This paper shows how Long Short-term Memory recurrent neural networks can be used to generate complex sequences with long-range structure, simply by predicting one data point at a time. The approach is demonstrated for text (where the data are discrete) and online handwriting (where the data are real-valued). It is then extended to handwriting synthesis by allowing the network to condition its predictions on a text sequence. The resulting system is able to generate highly realistic cursive handwriting in a wide variety of styles.

For agents

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

get_harvested_code_for_paper("1308.0850")
get_code_for_paper("1308.0850")
have("1308.0850")

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

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

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

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

Connect an agent — have() is free.