| BLEU_score |
Ran ran on a synthesized input |
yurayli/image_caption_pytorch/eval_metrics.py code served (permissive licence) · get_code("4e8ebb8599fb73e6") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import nltk
# Download required NLTK data
try:
nltk.data.find('tokenizers/punkt')
except LookupError:
nltk.download('punkt', quiet=True)
# Create sample ground-truth and predicted captions
gt_caption = "a cat sitting on a mat <start> the cat is very cute <end>"
sample_caption = "a cat is sitting on the mat <start> very cute <end>"
ARGS = {
"gt_caption": gt_caption,
"sample_caption": sample_caption,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- nltk — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| Magnitude |
Ran ran on a synthesized input |
shaox192/NeuralGuidance/analysis/smoothness.py code served (permissive licence) · get_code("88947ef0639ed6bb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# g1 is a 2D tensor that will be squared, summed along dimension 1, and then meaned
# The function does: torch.sum(g1 ** 2, 1).mean() * 2 * 200
# g1 needs to be a tensor with shape (batch_size, features)
# Using batch_size=2, features=4 as specified
g1 = torch.randn(2, 4)
ARGS = {
"g1": g1
}
- 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
|
| accuracy |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
shaox192/NeuralGuidance/analysis/utils.py code served (permissive licence) · get_code("b0f936d4d6ae3b8c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned list, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create output tensor: batch_size=2, num_classes=4
# This represents logits from a model
output = torch.randn(2, 4)
# Create target tensor: batch_size=2
# These are class indices (0-3 for 4 classes)
target = torch.tensor([1, 3])
# topk parameter: tuple of k values to compute accuracy for
topk = (1, 2)
ARGS = {
"output": output,
"target": target,
"topk": topk,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 2, 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
|
| accuracy |
Ran ran; our contract draft was wrong, not the code |
Japanese-Image-Captioning/SAT-for-Japanese/utils.py code served (permissive licence) · get_code("53daad1d7b99fbdf") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Construct small tensors for the function
batch_size = 2
num_classes = 4
k = 2
# scores: model predictions with shape (batch_size, num_classes)
scores = torch.randn(batch_size, num_classes)
# targets: true labels with shape (batch_size,)
targets = torch.randint(0, num_classes, (batch_size,))
ARGS = {
"scores": scores,
"targets": targets,
"k": k,
}
- 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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| accuracy |
Ran ran on a synthesized input |
djain454/Show-Attend-and-Tell-Neural-Image-Caption-Generation-with-Visual-Attention/utils.py code served (permissive licence) · get_code("fc7e660e3ad2dd0e") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Create predictions tensor: shape (batch_size=2, num_classes=4)
# topk will select k largest values along dimension 1
preds = torch.randn(2, 4)
# Create targets tensor: shape (batch_size=2,)
# Values should be class indices in range [0, num_classes)
targets = torch.tensor([0, 2])
# k for top-k accuracy
k = 2
ARGS = {
"preds": preds,
"targets": targets,
"k": k
}
- 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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| cal_noise_ceiling_single_vox |
Ran ran on a synthesized input |
shaox192/NeuralGuidance/analysis/noise_ceiling.py code served (permissive licence) · get_code("ecb092757c4db425") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create sample data for the function
# The function expects data with shape (n_voxels, n_samples)
# We'll create a small dataset with 3 voxels and 5 samples
np.random.seed(0)
data = np.random.randn(3, 5)
ARGS = {
"data": data
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| calc_max_length |
Ran ran, honoured the contract we drafted |
ishritam/Image-captioning-with-visual-attention/image_cap.py pointer only (licence: NONE) · get_code("af5b85578e4e6f1b") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, ishritam/Image-captioning-with-visual-attention 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. |
| calculate_caption_lengths |
Ran ran on a synthesized input |
djain454/Show-Attend-and-Tell-Neural-Image-Caption-Generation-with-Visual-Attention/utils.py code served (permissive licence) · get_code("9f843b78744f8406") 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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create a word dictionary with special tokens
word_dict = {
'<start>': 0,
'<eos>': 1,
'<pad>': 2,
'hello': 3,
'world': 4,
'test': 5
}
# Create captions as a list of lists of token indices
# Each inner list represents tokens in a caption
captions = [
[0, 3, 4, 1], # [<start>, hello, world, <eos>]
[0, 5, 3, 1, 2] # [<start>, test, hello, <eos>, <pad>]
]
ARGS = {
'word_dict': word_dict,
'captions': captions
}
- 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 int, ndim 0, dtype family int, 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
|
| caption_features |
Ran ran on a synthesized input |
martincss/first-captioning/preprocess_tokenize_captions.py code served (permissive licence) · get_code("68d2533729c9efa1") 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 (2, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tensorflow as tf
class MockTokenizer:
def texts_to_sequences(self, texts):
# Return sequences of different lengths for realistic padding test
return [
[1, 2, 3],
[4, 5]
]
train_captions = [
"a cat sitting on a mat",
"a dog running"
]
tokenizer = MockTokenizer()
maxlen = 5
ARGS = {
"train_captions": train_captions,
"tokenizer": tokenizer,
"maxlen": maxlen
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- tensorflow — 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 (2, 5) — shape (2, 5) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_numeric_gradient |
Ran ran on a synthesized input |
leob03/Image_captionning/utils/grad.py code served (permissive licence) · get_code("112c9a161e488e7c") 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, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Simple function that takes a tensor and returns a scalar
def simple_f(x):
"""A simple quadratic function: sum of x^2"""
return (x ** 2).sum()
# Create a small input tensor
x = torch.randn(2, 3, requires_grad=False)
# Optional upstream gradient (None will default to ones)
dLdf = None
# Finite difference step size
h = 1e-07
ARGS = {
"f": simple_f,
"x": x,
"dLdf": dLdf,
"h": h,
}
- 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, 3) — shape (2, 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
|
| cook_refs |
Ran ran; our contract draft was wrong, not the code |
coldmanck/show-attend-and-tell/utils/coco/pycocoevalcap/cider/cider_scorer.py pointer only (licence: MIT); the stored copy get_code serves, from wenhuchen/data-to-text-evaluation-metric, is pointer only (licence: NOASSERTION) · get_code("4c1b107103b7c856") How it ranThe body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from wenhuchen/data-to-text-evaluation-metric, and GitHub could not classify the licence of that repository (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| cook_refs |
Ran ran; our contract draft was wrong, not the code |
coldmanck/show-attend-and-tell/utils/coco/pycocoevalcap/bleu/bleu_scorer.py code served (permissive licence) · get_code("7586e1d32f7325f7") 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 collections import defaultdict
ARGS = {
'refs': [
'the quick brown fox jumps over the lazy dog',
'a quick brown fox leaps over a lazy dog'
],
'eff': 'shortest',
'n': 4
}
- 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 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
|
| cook_test |
Ran ran; our contract draft was wrong, not the code |
coldmanck/show-attend-and-tell/utils/coco/pycocoevalcap/cider/cider_scorer.py pointer only (licence: MIT); the stored copy get_code serves, from wenhuchen/data-to-text-evaluation-metric, is pointer only (licence: NOASSERTION) · get_code("3573c4bc85f65dfd") How it ranThe body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from wenhuchen/data-to-text-evaluation-metric, and GitHub could not classify the licence of that repository (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| cook_test |
Ran ran on a synthesized input |
coldmanck/show-attend-and-tell/utils/coco/pycocoevalcap/bleu/bleu_scorer.py code served (permissive licence) · get_code("99e54843980299e2") 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.
from collections import defaultdict
def precook(s, n=4, out=False):
"""Takes a string as input and returns an object that can be given to
either cook_refs or cook_test. This is optional: cook_refs and cook_test
can take string arguments as well."""
words = s.split()
counts = defaultdict(int)
for k in range(1, n + 1):
for i in range(len(words) - k + 1):
ngram = tuple(words[i:i + k])
counts[ngram] += 1
return (len(words), counts)
def cook_test(test, refs, eff=None, n=4):
"""Takes a test sentence and returns an object that
encapsulates everything that BLEU needs to know about it."""
reflen, refmaxcounts = refs
testlen, counts = precook(test, n, True)
result = {}
if eff == 'closest':
result['reflen'] = min(((abs(l - testlen), l) for l in reflen))[1]
else:
result['reflen'] = reflen
result['testlen'] = testlen
result['guess'] = [max(0, testlen - k + 1) for k in range(1, n + 1)]
result['correct'] = [0] * n
for ngram, count in counts.items():
result['correct'][len(ngram) - 1] += min(refmaxcounts.get(ngram, 0), count)
return result
# Build test arguments
test_string = "the quick brown fox jumps over the lazy dog"
# Create reference data using precook
ref_string_1 = "the quick brown fox jumps over the lazy dog"
ref_string_2 = "a fast brown fox leaps over the lazy dog"
reflen_1, refcounts_1 = precook(ref_string_1, n=4)
reflen_2, refcounts_2 = precook(ref_string_2, n=4)
# Merge reference counts (take max for each ngram)
refmaxcounts = defaultdict(int)
for ngram, count in refcounts_1.items():
refmaxcounts[ngram] = max(refmaxcounts[ngram], count)
for ngram, count in refcounts_2.items():
refmaxcounts[ngram] = max(refmaxcounts[ngram], count)
# Create refs tuple
refs = ([reflen_1, reflen_2], refmaxcounts)
ARGS = {
'test': test_string,
'refs': refs,
'eff': None,
'n': 4
}
- 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 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
|
| correlation |
Ran ran on a synthesized input |
shaox192/NeuralGuidance/neural_guidance_training/model.py code served (permissive licence) · get_code("e9b0f77f1b690e9a") 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
torch.manual_seed(0)
# The function expects two tensors X and Y
# Looking at the einsum operations: 'ab,ab->a'
# This means:
# - X and Y should be 2D tensors with shape (batch_size, feature_dim)
# - The operation computes correlations along the batch dimension
# - batch_size=2, feature_dim=4 as per requirements
X = torch.randn(2, 4)
Y = torch.randn(2, 4)
ARGS = {
'X': X,
'Y': Y
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 1, dtype family float, shape (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
|
| create_padding_mask |
Ran ran; our contract draft was wrong, not the code |
krasserm/fairseq-image-captioning/model/caption.py code served (permissive licence) · get_code("f93be7ac25d7dac1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create small tensors for testing
# src_tokens: shape (batch_size, seq_length) - token indices
batch_size = 2
seq_length = 4
src_tokens = torch.randint(0, 100, (batch_size, seq_length), dtype=torch.long)
# src_lengths: list/tensor of actual lengths for each sequence in batch
# These should be <= seq_length
src_lengths = [2, 3]
ARGS = {
"src_tokens": src_tokens,
"src_lengths": src_lengths,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| extract_features |
Ran ran on a synthesized input |
yurayli/image_caption_pytorch/solver.py code served (permissive licence) · get_code("92cdbcd5d83f0f6d") 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, 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 torch
import torch.nn as nn
torch.manual_seed(0)
class SimpleNet(nn.Module):
def __init__(self):
super().__init__()
self.layer1 = nn.Linear(4, 8)
self.layer2 = nn.Linear(8, 6)
self.layer3 = nn.Linear(6, 3)
def forward(self, x):
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
return x
net = SimpleNet()
xs = torch.randn(2, 4)
ARGS = {
"net": net,
"xs": xs
}
- 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, 6) — shape (2, 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
|
| feed_forward_net |
Ran ran on a synthesized input |
yurayli/image_caption_pytorch/encode_image.py code served (permissive licence) · get_code("aa4791e2bffdf413") 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, 10) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import torch.nn.functional as F
torch.manual_seed(0)
# Create a minimal Inception V3-like net
class MinimalInceptionV3(nn.Module):
def __init__(self):
super().__init__()
self.module1 = nn.Conv2d(3, 8, kernel_size=3, padding=1)
self.module2 = nn.Conv2d(8, 8, kernel_size=3, padding=1)
self.module3 = nn.Conv2d(8, 8, kernel_size=3, padding=1)
self.module4 = nn.Conv2d(8, 16, kernel_size=3, padding=1)
self.module5 = nn.Conv2d(16, 16, kernel_size=3, padding=1)
self.module6 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
self.module7 = nn.Conv2d(32, 32, kernel_size=3, padding=1)
self.module8 = nn.Conv2d(32, 32, kernel_size=3, padding=1)
self.module9 = nn.Conv2d(32, 32, kernel_size=3, padding=1)
self.module10 = nn.Conv2d(32, 16, kernel_size=1)
def forward(self, x):
x = self.module1(x)
return x
# Create a minimal DenseNet161-like net
class MinimalDenseNet(nn.Module):
def __init__(self):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 16, kernel_size=3, padding=1),
nn.Conv2d(16, 32, kernel_size=3, padding=1)
)
def forward(self, x):
return self.features(x)
# Create a minimal ResNet101-like net
class MinimalResNet(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
self.layer1 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
self.layer2 = nn.Conv2d(32, 32, kernel_size=3, padding=1)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(32, 10)
def forward(self, x):
x = self.conv1(x)
return x
# Create a minimal VGG16-like net
class MinimalVGG(nn.Module):
def __init__(self):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 16, kernel_size=3, padding=1),
nn.Conv2d(16, 32, kernel_size=3, padding=1)
)
self.classifier = nn.Sequential(
nn.Linear(32 * 4 * 4, 64),
nn.Linear(64, 10)
)
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x
# Small test tensor (batch=2, channels=3, height=4, width=4)
xs = torch.randn(2, 3, 4, 4)
ARGS = {
'xs': xs,
'net': MinimalVGG(),
'pre_net': 'vgg16',
'spatial': False
}
- 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, 10) — shape (2, 10) 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
|
| getFileNameToSave |
Ran ran on a synthesized input |
LinXueyuanStdio/LaTeX_OCR/visualize_attention.py code served (permissive licence) · get_code("891b8f71cfafca9a") 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
path_to_save_attention = "/tmp/attention_output"
i = 0
ARGS = {
"path_to_save_attention": path_to_save_attention,
"i": i
}
- 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
|
| getOutArray |
Ran ran on a synthesized input |
LinXueyuanStdio/LaTeX_OCR/visualize_attention.py code served (permissive licence) · get_code("d7419b2156f83b93") 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 (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
import torch
torch.manual_seed(0)
# Create a small attention vector with shape (1, height*width)
# Using att_h=3, att_w=4, so flattened size is 12
att_h = 3
att_w = 4
attention_size = att_h * att_w
# Create attention vector with values between 0 and 1
attentionVector = np.random.rand(1, attention_size).astype(np.float32)
ARGS = {
"attentionVector": attentionVector,
"att_w": att_w,
"att_h": att_h
}
- 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 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
|
| getWH |
Ran ran on a synthesized input |
LinXueyuanStdio/LaTeX_OCR/visualize_attention.py code served (permissive licence) · get_code("54e482c9c86eec94") 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 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 numpy as np
ARGS = {
'img_w': 640,
'img_h': 480
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family int — 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
|
| get_dist_matrix |
Ran ran on a synthesized input |
shaox192/NeuralGuidance/analysis/RSA.py code served (permissive licence) · get_code("8a9b2d5877d086a3") 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)
# Create a small data matrix: 2 samples, 4 features
data_mat = torch.randn(2, 4)
# Test with 'corr' method
ARGS = {
'data_mat': data_mat,
'method': 'corr'
}
- 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
|
| get_hypotheses |
Ran ran on a synthesized input |
lvyufeng/image_captioning_mindspore/src/utils.py code served (permissive licence) · get_code("2d423582a2c44126") 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. 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)
# Create a small predictions tensor (batch_size=2, sequence_length=4)
# The function calls .tolist() on predictions and indexes with cap_lens
predictions = torch.tensor([
[1, 2, 3, 4],
[5, 6, 7, 8]
], dtype=torch.long)
# Create cap_lens list with different lengths for each batch element
# These values indicate how many elements to keep from each prediction
cap_lens = [2, 3]
ARGS = {
"predictions": predictions,
"cap_lens": cap_lens
}
- 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 — 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
|
| get_model_corr_mat |
Ran ran on a synthesized input |
shaox192/NeuralGuidance/analysis/RSA.py code served (permissive licence) · get_code("70e878dc080d6418") 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 (4, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The function expects lbs (labels) to be a 1D tensor of shape (batch_size,)
# It performs element-wise comparison to create a same_label_matrix
# Then uses torch.where to create a model_matrix
lbs = torch.tensor([0, 1, 0, 1], dtype=torch.long)
ARGS = {
"lbs": lbs
}
- 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 (4, 4) — shape (4, 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
|
| get_model_weights |
Ran ran on a synthesized input |
shaox192/NeuralGuidance/manifold_guidance/man_cotrain.py code served (permissive licence) · get_code("29c867d79b8c8f8e") 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 ResNet18_Weights. 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 torchvision.models as models
torch.manual_seed(0)
ARGS = {
'arch': 'resnet18'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ResNet18_Weights — a ResNet18_Weights output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ResNet18_Weights 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
|
| get_references |
Ran ran on a synthesized input |
lvyufeng/image_captioning_mindspore/src/utils.py code served (permissive licence) · get_code("9ee8094f76ff694d") 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. 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)
# Build word_map with required special tokens
word_map = {
'<start>': 0,
'<pad>': 1,
'hello': 2,
'world': 3,
'test': 4,
}
# Build all_captions as a 2D tensor where each row contains encoded captions
# Shape: (num_images, max_captions_per_image, max_caption_length)
# But looking at the function, it treats all_captions[j] as a list of captions
# So we need shape (num_images, num_captions, caption_length)
all_captions = torch.tensor([
[[0, 2, 3, 1], [0, 4, 1, 1]], # Image 0: 2 captions of length 4
[[0, 2, 4, 1], [0, 3, 1, 1]], # Image 1: 2 captions of length 4
], dtype=torch.long)
ARGS = {
'all_captions': all_captions,
'word_map': word_map,
}
- 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 — 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
|
| get_repeated_image |
Ran ran on a synthesized input |
shaox192/NeuralGuidance/analysis/noise_ceiling.py code served (permissive licence) · get_code("cd8511add99a8df2") 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 torch
import numpy as np
torch.manual_seed(0)
# Analyze the function:
# - full_beta_data: not used in the function body, can be any object
# - ordering: used with len() and indexing [trial_id], should be a list-like of image IDs
# Create minimal valid arguments
full_beta_data = None # Not used in function body
# ordering: list of image IDs, where some images appear exactly 3 times
# Create an ordering where:
# - image_id 0 appears at trials 0, 1, 2 (3 times)
# - image_id 1 appears at trials 3, 4, 5 (3 times)
# - image_id 2 appears at trials 6, 7 (2 times - should be filtered out)
# - image_id 3 appears at trial 8 (1 time - should be filtered out)
ordering = [0, 0, 0, 1, 1, 1, 2, 2, 3]
ARGS = {
"full_beta_data": full_beta_data,
"ordering": ordering
}
- 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 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
|
| get_toy_data |
Ran ran on a synthesized input |
leob03/Image_captionning/main_func.py code served (permissive licence) · get_code("c5e0eb463e9afc32") 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 json
import tempfile
import os
# Create a temporary JSON file with toy data
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, 'final_data.json')
toy_data = {
"samples": [
{"id": 1, "value": "test1"},
{"id": 2, "value": "test2"}
],
"metadata": {"version": "1.0"}
}
with open(temp_file, 'w') as f:
json.dump(toy_data, f)
ARGS = {
'path': temp_file
}
- 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 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
|
| image_fnames_captions |
Ran ran on a synthesized input |
martincss/first-captioning/coco_utils.py code served (permissive licence) · get_code("c369482485646bd1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import json
import tempfile
from pathlib import Path
# Create a temporary directory and files for testing
temp_dir = tempfile.TemporaryDirectory()
temp_path = Path(temp_dir.name)
# Create a mock captions file
captions_data = {
"annotations": [
{
"image_id": 1,
"caption": "a dog running in the park"
},
{
"image_id": 2,
"caption": "a cat sitting on a mat"
},
{
"image_id": 123456789012,
"caption": "a bird flying in the sky"
}
]
}
captions_file = temp_path / "captions.json"
with open(captions_file, 'w') as f:
json.dump(captions_data, f)
# Create images directory
images_dir = temp_path / "images"
images_dir.mkdir(exist_ok=True)
# Create dummy image files
for image_id in [1, 2, 123456789012]:
img_path = images_dir / ('COCO_train2014_{:012d}.jpg'.format(image_id))
img_path.touch()
ARGS = {
"captions_file": str(captions_file),
"images_dir": images_dir,
"partition": "train"
}
- 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 tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| itemlist |
Ran ran; our contract draft was wrong, not the code |
Zhangyuewei98/arctic-captions-py3/capgen.py pointer only (licence: NONE) · get_code("8569db484e9d39b6") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, Zhangyuewei98/arctic-captions-py3 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. |
| load |
Ran ran on a synthesized input |
codekansas/keras-language-modeling/generate_insurance_qa_embeddings.py code served (permissive licence) · get_code("eccb788cbbf8f688") 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 os
import pickle
import tempfile
# Create a temporary directory to use as the path
temp_dir = tempfile.mkdtemp()
# Create a sample object to pickle
sample_data = {
'model_weights': [1.0, 2.0, 3.0],
'config': {'learning_rate': 0.001, 'epochs': 10},
'results': [0.95, 0.96, 0.97]
}
# Pickle the sample data to a file
filename = 'test_data.pkl'
filepath = os.path.join(temp_dir, filename)
with open(filepath, 'wb') as f:
pickle.dump(sample_data, f)
# Define the arguments for the load function
ARGS = {
'path': temp_dir,
'name': filename
}
- 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 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_coco_captions |
Ran ran on a synthesized input |
leob03/Image_captionning/main_func.py code served (permissive licence) · get_code("088be7e4343bda87") 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 torch
import tempfile
import os
torch.manual_seed(0)
# Create a minimal COCO dataset dictionary and save it to a temporary file
temp_dir = tempfile.mkdtemp()
temp_path = os.path.join(temp_dir, 'coco.pt')
# Create minimal data dictionary matching the expected structure
data_dict = {
'train_images': torch.randn(2, 3, 112, 112), # 2 training images, 3 channels, 112x112
'val_images': torch.randn(3, 3, 112, 112), # 3 validation images, 3 channels, 112x112
'train_captions': torch.randint(0, 100, (2, 15)), # 2 captions, max length 15
'val_captions': torch.randint(0, 100, (3, 15)), # 3 captions, max length 15
'vocab': {
'idx_to_token': ['<pad>', '<unk>', 'the', 'a', 'cat', 'dog', 'sits', 'on', 'mat'],
'token_to_idx': {
'<pad>': 0,
'<unk>': 1,
'the': 2,
'a': 3,
'cat': 4,
'dog': 5,
'sits': 6,
'on': 7,
'mat': 8
}
}
}
# Save the data dictionary to the temporary path
torch.save(data_dict, temp_path)
# Define ARGS with the path to the temporary file
ARGS = {
'path': temp_path
}
- 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 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_embeddings |
Ran ran; our contract draft was wrong, not the code |
Japanese-Image-Captioning/SAT-for-Japanese/utils.py code served (permissive licence) · get_code("4cc9097b30b644e0") 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
import tempfile
import os
torch.manual_seed(0)
# Create a temporary embedding file in GloVe format
temp_dir = tempfile.mkdtemp()
emb_file = os.path.join(temp_dir, "embeddings.txt")
# Create a small GloVe-format embedding file
# Format: word dim1 dim2 dim3 dim4
with open(emb_file, 'w') as f:
f.write("apple 0.1 0.2 0.3 0.4\n")
f.write("banana 0.5 0.6 0.7 0.8\n")
f.write("cherry 0.9 1.0 1.1 1.2\n")
f.write("date 1.3 1.4 1.5 1.6\n")
# Create a word_map that maps words to indices
word_map = {
"apple": 0,
"banana": 1,
"cherry": 2,
"date": 3,
"elderberry": 4,
}
ARGS = {
"emb_file": emb_file,
"word_map": word_map,
}
- 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
|
| load_image |
Ran ran on a synthesized input |
martincss/first-captioning/preprocess_encode_images.py code served (permissive licence) · get_code("b0bb3778f118bff1") 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 tensorflow as tf
import tempfile
import os
from PIL import Image
import numpy as np
# Create a temporary JPEG image file for testing
temp_dir = tempfile.mkdtemp()
img_array = np.random.randint(0, 256, (224, 224, 3), dtype=np.uint8)
img = Image.fromarray(img_array)
image_path = os.path.join(temp_dir, "test_image.jpg")
img.save(image_path)
ARGS = {
"image_path": image_path,
"cnn_encoder": "InceptionV3"
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL, numpy, tensorflow — 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
|
| load_img_folder_ls |
Ran ran on a synthesized input |
shaox192/NeuralGuidance/manifold_guidance/man_data_loader.py code served (permissive licence) · get_code("b8d0de38fa1b3c8b") 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
# Create a temporary text file with folder paths
with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
f.write("/path/to/folder1: some metadata\n")
f.write("/path/to/folder2: some metadata\n")
f.write("/path/to/folder3: some metadata\n")
txt_file_path = f.name
try:
ARGS = {
'txt_pth': txt_file_path
}
finally:
# Clean up the temporary file after defining ARGS
pass
- 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
|
| load_textfiles |
Ran ran; our contract draft was wrong, not the code |
Zhangyuewei98/arctic-captions-py3/metrics.py pointer only (licence: NONE) · get_code("05ec0ad6e8114d01") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, Zhangyuewei98/arctic-captions-py3 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. |
| make_tokenizer |
Ran ran on a synthesized input |
martincss/first-captioning/preprocess_tokenize_captions.py code served (permissive licence) · get_code("6954f2198f23dbee") 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 Tokenizer. 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 tensorflow as tf
# Create small sample captions for training the tokenizer
train_captions = [
"a cat sitting on the mat",
"a dog running in the park",
"a bird flying in the sky",
"the cat is sleeping",
"dogs love to play fetch"
]
# Set top_k to a reasonable value for vocabulary size
top_k = 20
ARGS = {
"train_captions": train_captions,
"top_k": top_k
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tokenizer — a Tokenizer output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Tokenizer 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
|
| pickle_load |
Ran ran on a synthesized input |
shaox192/NeuralGuidance/analysis/utils.py code served (permissive licence) · get_code("198d90979fd0346e") 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 pickle as pkl
import tempfile
import os
# Create a temporary file and pickle some data into it
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, "test_data.pkl")
# Create sample data to pickle
sample_data = {
"key1": "value1",
"key2": [1, 2, 3, 4, 5],
"key3": {"nested": "dict"}
}
# Write the pickled data to the temporary file
with open(temp_file, 'wb') as f:
pkl.dump(sample_data, f)
# Define ARGS
ARGS = {
"fpth": temp_file
}
- 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 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
|
| pil_loader |
Ran ran, honoured the contract we drafted |
shaox192/NeuralGuidance/manifold_guidance/man_data_loader.py pointer only (licence: Apache-2.0); the stored copy get_code serves, from zhentingwang/diagnosis, is pointer only (licence: NONE) · get_code("f6be833ba409926f") How it ranThe body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from zhentingwang/diagnosis, and GitHub detected no licence in that repository 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. |
| pil_loader |
Ran ran, honoured the contract we drafted |
djain454/Show-Attend-and-Tell-Neural-Image-Caption-Generation-with-Visual-Attention/dataset.py code served (permissive licence) · get_code("f321f54723433661") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Image. 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
from PIL import Image
import io
import os
import tempfile
# Create a temporary directory for test files
temp_dir = tempfile.mkdtemp()
# Create a simple RGB image and save it to a temporary file
img = Image.new('RGB', (10, 10), color=(73, 109, 137))
test_image_path = os.path.join(temp_dir, 'test_image.jpg')
img.save(test_image_path)
ARGS = {
'path': test_image_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- PIL, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 and dtype family int 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
|
| precook |
Ran ran; our contract draft was wrong, not the code |
coldmanck/show-attend-and-tell/utils/coco/pycocoevalcap/bleu/bleu_scorer.py code served (permissive licence) · get_code("ec4448373d72d636") 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 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.
ARGS = {
"s": "the quick brown fox jumps over the lazy dog",
"n": 4,
"out": False
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- 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 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
|
| precook |
Ran ran; our contract draft was wrong, not the code |
coldmanck/show-attend-and-tell/utils/coco/pycocoevalcap/cider/cider_scorer.py pointer only (licence: MIT); the stored copy get_code serves, from wenhuchen/data-to-text-evaluation-metric, is pointer only (licence: NOASSERTION) · get_code("9560e3e3e41bc1b2") How it ranThe body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from wenhuchen/data-to-text-evaluation-metric, and GitHub could not classify the licence of that repository (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| process_caption_tokens |
Ran ran on a synthesized input |
djain454/Show-Attend-and-Tell-Neural-Image-Caption-Generation-with-Visual-Attention/generate_json_data.py code served (permissive licence) · get_code("369a98c031b8ad9d") 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 2, 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)
# Build a minimal word_dict with required special tokens and some sample words
word_dict = {
'<start>': 0,
'<eos>': 1,
'<pad>': 2,
'<unk>': 3,
'cat': 4,
'dog': 5,
'sits': 6,
'runs': 7,
}
# Build caption_tokens as a list of token sequences
caption_tokens = [
['cat', 'sits'],
['dog', 'runs', 'fast'],
]
# Set max_length to accommodate the longest caption plus start and eos tokens
max_length = 5
ARGS = {
'caption_tokens': caption_tokens,
'word_dict': word_dict,
'max_length': max_length,
}
- 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 2, 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
|
| rel_error |
Ran ran on a synthesized input |
leob03/Image_captionning/utils/grad.py code served (permissive licence) · get_code("0a60ca96331ba158") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create two small tensors of the same shape
x = torch.randn(2, 4)
y = torch.randn(2, 4)
ARGS = {
"x": x,
"y": y,
"eps": 1e-10
}
- 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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| remove_special_tokens |
Ran ran; our contract draft was wrong, not the code |
yurayli/image_caption_pytorch/eval_metrics.py code served (permissive licence) · get_code("9bfeeae84da4c830") 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 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.
ARGS = {
"caption_text": "a <start> photo of a cat <end> sitting on <unk> the mat"
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- 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 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
|
| rnn_forward |
Ran ran on a synthesized input |
leob03/Image_captionning/rnn_lstm_captioning.py code served (permissive licence) · get_code("818e7744734a9021") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Define dimensions
N = 2 # batch size
T = 3 # sequence length
D = 4 # input dimension
H = 5 # hidden dimension
# Create input tensor of shape (N, T, D)
x = torch.randn(N, T, D)
# Create initial hidden state of shape (N, H)
h0 = torch.randn(N, H)
# Create weight matrix for input-to-hidden of shape (D, H)
Wx = torch.randn(D, H)
# Create weight matrix for hidden-to-hidden of shape (H, H)
Wh = torch.randn(H, H)
# Create bias vector of shape (H,)
b = torch.randn(H)
ARGS = {
'x': x,
'h0': h0,
'Wx': Wx,
'Wh': Wh,
'b': b
}
- 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
|
| rnn_step_backward |
Ran ran on a synthesized input |
leob03/Image_captionning/rnn_lstm_captioning.py code served (permissive licence) · get_code("7459c63f19bd1a20") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Define dimensions
N = 2 # batch size
D = 4 # input dimension
H = 3 # hidden dimension
# Create cache tuple containing (x, prev_h, Wx, Wh, b)
x = torch.randn(N, D)
prev_h = torch.randn(N, H)
Wx = torch.randn(D, H)
Wh = torch.randn(H, H)
b = torch.randn(H)
cache = (x, prev_h, Wx, Wh, b)
# Create gradient of loss with respect to next hidden state
dnext_h = torch.randn(N, H)
ARGS = {
"dnext_h": dnext_h,
"cache": cache
}
- 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
|
| rnn_step_forward |
Ran ran on a synthesized input |
leob03/Image_captionning/rnn_lstm_captioning.py code served (permissive licence) · get_code("a4639ecce23676b1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Define dimensions
N = 2 # batch size
D = 4 # input dimension
H = 3 # hidden dimension
# Create input data for this timestep
x = torch.randn(N, D)
# Create hidden state from previous timestep
prev_h = torch.randn(N, H)
# Create weight matrices
Wx = torch.randn(D, H)
Wh = torch.randn(H, H)
# Create bias vector
b = torch.randn(H)
ARGS = {
'x': x,
'prev_h': prev_h,
'Wx': Wx,
'Wh': Wh,
'b': b
}
- 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
|
| run_clean |
Ran ran on a synthesized input |
shaox192/NeuralGuidance/analysis/RSA.py code served (permissive licence) · get_code("e2a84722a01bf8a0") 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. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Create a minimal model that takes images and returns neural outputs
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, x):
# x shape: (batch_size, 4)
return self.linear(x)
# Create a minimal data loader as a list of (images, labels) tuples
val_loader = [
(torch.randn(2, 4), torch.randint(0, 3, (2,))),
(torch.randn(2, 4), torch.randint(0, 3, (2,))),
(torch.randn(2, 4), torch.randint(0, 3, (2,))),
(torch.randn(2, 4), torch.randint(0, 3, (2,))),
]
# Create the model
model = SimpleModel()
ARGS = {
'val_loader': val_loader,
'model': model,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| split_captions |
Ran ran on a synthesized input |
yurayli/image_caption_pytorch/data_utils.py code served (permissive licence) · get_code("5ce371a11110cca1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
import os
# Create a temporary directory and files for testing
temp_dir = tempfile.mkdtemp()
path = temp_dir + "/"
# Create the Flickr8k.token.txt file with sample data
token_file_content = """image1.jpg#0 a dog is running in the park
image1.jpg#1 the dog runs fast
image1.jpg#2 a brown dog playing
image2.jpg#0 cats sitting on the fence
image2.jpg#1 two cats on wood
image3.jpg#0 a bird flying high
image3.jpg#1 the bird soars through sky"""
with open(path + 'Flickr8k.token.txt', 'w') as f:
f.write(token_file_content)
# Define training and test file lists (image IDs without the #N suffix)
trn_files = ['image1.jpg', 'image2.jpg']
test_files = ['image3.jpg']
ARGS = {
'path': path,
'trn_files': trn_files,
'test_files': test_files
}
- 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 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
|
| split_hparams |
Ran ran on a synthesized input |
martincss/first-captioning/grid_search.py code served (permissive licence) · get_code("8b4a39f185ba405c") 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 torch
import numpy as np
ARGS = {
'hparams': {
'embedding_dim': 64,
'units': 128,
'lstm_units': 256,
'n_layers_init': 2,
'n_layers_att': 3,
'init_dropout': 0.1,
'attn_dropout': 0.2,
'lstm_dropout': 0.15,
'logit_dropout': 0.05,
'l1_reg': 0.001,
'l2_reg': 0.002,
'lambda_reg': 0.5,
'optimizer': 'adam',
'learning_rate': 0.001
}
}
- 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 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
|
| split_image_files |
Ran ran on a synthesized input |
yurayli/image_caption_pytorch/data_utils.py code served (permissive licence) · get_code("b6424d334cb20b0b") 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 os
import tempfile
import shutil
# Create a temporary directory structure to mock the Flickr8k dataset
temp_dir = tempfile.mkdtemp()
path = temp_dir + '/'
# Create the Flicker8k_Dataset directory with some image files
dataset_dir = os.path.join(temp_dir, 'Flicker8k_Dataset')
os.makedirs(dataset_dir, exist_ok=True)
# Create some dummy image files
image_files = ['image1.jpg', 'image2.jpg', 'image3.jpg', 'image4.jpg', 'image5.jpg']
for img in image_files:
open(os.path.join(dataset_dir, img), 'w').close()
# Create train images file
train_images = ['image1.jpg', 'image2.jpg']
with open(os.path.join(temp_dir, 'Flickr_8k.trainImages.txt'), 'w') as f:
f.write('\n'.join(train_images))
# Create dev images file
dev_images = ['image3.jpg']
with open(os.path.join(temp_dir, 'Flickr_8k.devImages.txt'), 'w') as f:
f.write('\n'.join(dev_images))
# Create test images file
test_images = ['image4.jpg', 'image5.jpg']
with open(os.path.join(temp_dir, 'Flickr_8k.testImages.txt'), 'w') as f:
f.write('\n'.join(test_images))
ARGS = {
'path': 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 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
|
| tensor_to_image |
Ran ran on a synthesized input |
leob03/Image_captionning/utils/utils.py code served (permissive licence) · get_code("bc260615679a81dd") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family int, shape (4, 5, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Create a valid tensor input: shape (3, H, W) with elements in [0, 1]
H, W = 4, 5
tensor = torch.rand(3, H, W)
ARGS = {
'tensor': tensor
}
- 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 ndarray, ndim 3, dtype family int, shape (4, 5, 3) — shape (4, 5, 3) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| to_var |
Ran ran; our contract draft was wrong, not the code |
TheZino/Image_captioning_SATell/models.py pointer only (licence: NONE) · get_code("502c50812b7f31ab") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, TheZino/Image_captioning_SATell 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. |
| train_captioner |
Ran ran on a synthesized input |
leob03/Image_captionning/main_func.py code served (permissive licence) · get_code("0a5ea4832aa6d5f3") 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 torch.nn as nn
import math
torch.manual_seed(0)
class SimpleCaptioner(nn.Module):
"""Minimal captioner model that accepts images and captions and returns a loss."""
def __init__(self, image_dim, caption_dim):
super().__init__()
self.fc = nn.Linear(image_dim, caption_dim)
self.loss_fn = nn.MSELoss()
def forward(self, images, captions):
# images: (batch_size, image_dim)
# captions: (batch_size, caption_dim)
# Return a scalar loss
output = self.fc(images)
loss = self.loss_fn(output, captions)
return loss
# Create minimal tensors
image_dim = 4
caption_dim = 3
batch_size = 2
num_samples = 6
# Image data: (num_samples, image_dim)
image_data = torch.randn(num_samples, image_dim)
# Caption data: (num_samples, caption_dim)
caption_data = torch.randn(num_samples, caption_dim)
# Create model
model = SimpleCaptioner(image_dim, caption_dim)
ARGS = {
'model': model,
'image_data': image_data,
'caption_data': caption_data,
'num_epochs': 2,
'batch_size': batch_size,
'learning_rate': 0.01,
'lr_decay': 0.95,
'device': torch.device('cpu')
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, 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
|
| unpickle |
Ran ran on a synthesized input |
Aaatresh/Seeing-through-sound/vOICe/data_generators/data_generator_cifar10.py code served (permissive licence) · get_code("bfc501c46e8ad1f9") 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 pickle
import tempfile
import os
# Create a temporary pickle file with sample data
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, "test_batch")
# Create sample data matching CIFAR-10 batch format
sample_data = {
b'batch_label': b'training batch 1',
b'labels': [0, 1, 2, 3, 4],
b'data': bytes(range(256)) * 50, # Mock image data
b'filenames': [b'file1.png', b'file2.png', b'file3.png', b'file4.png', b'file5.png']
}
# Pickle the sample data
with open(temp_file, 'wb') as f:
pickle.dump(sample_data, f)
ARGS = {
'file': temp_file
}
- 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 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
|
| visualize_dataset |
Ran ran on a synthesized input |
leob03/Image_captionning/utils/utils.py code served (permissive licence) · get_code("f534fbe3633b3692") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family int, shape (20, 14, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Create small tensors for X_data: [batch, 3, width, height]
# batch=10, 3 channels, 4x4 spatial dimensions
X_data = torch.rand(10, 3, 4, 4)
# Create corresponding labels: [batch]
# Labels for 3 classes (0, 1, 2)
y_data = torch.tensor([0, 0, 0, 0, 1, 1, 1, 2, 2, 2])
# Number of samples per class to visualize
samples_per_class = 2
# List of class names
class_list = ['class_0', 'class_1', 'class_2']
ARGS = {
'X_data': X_data,
'y_data': y_data,
'samples_per_class': samples_per_class,
'class_list': class_list
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy, torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 3, dtype family int, shape (20, 14, 3) — shape (20, 14, 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
|
| word_for_id |
Ran ran; our contract draft was wrong, not the code |
jaykshirsagar05/captionify/fastapi/caption.py code served (permissive licence) · get_code("8a04d895237560a5") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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
class StandInTokenizer:
def __init__(self):
self.word_index = {
'hello': 1,
'world': 2,
'python': 3,
'code': 4
}
tokenizer = StandInTokenizer()
integer = 2
ARGS = {
'integer': integer,
'tokenizer': tokenizer
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| accuracy |
Not yet run unverified (harvested, no recorded run) |
NicholasKX/ShowAttendTell/utils.py code served (permissive licence) · get_code("95216f51978817ce") How it ran |
| attention_visualizer |
Not yet run unverified (harvested, no recorded run) |
leob03/Image_captionning/utils/utils.py code served (permissive licence) · get_code("754d759415cbca01") How it ran |