| bias_analogy_test |
Ran ran on a synthesized input |
umanlp/debie-command-line/bias_evaluation/bat.py code served (permissive licence) · get_code("9b616b12c15d0fcb") 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 numpy as np
import logging
logging.basicConfig(level=logging.INFO)
# Create small embedding vectors (dimension 4)
embedding_dim = 4
# target1: dict of words -> vector representations
target1 = {
"word1": np.random.randn(embedding_dim),
"word2": np.random.randn(embedding_dim),
}
# target2: dict of words -> vector representations
target2 = {
"word3": np.random.randn(embedding_dim),
"word4": np.random.randn(embedding_dim),
}
# attribute1: dict of attribute words -> vector representations
attribute1 = {
"attr1": np.random.randn(embedding_dim),
"attr2": np.random.randn(embedding_dim),
}
# attribute2: dict of attribute words -> vector representations
attribute2 = {
"attr3": np.random.randn(embedding_dim),
"attr4": np.random.randn(embedding_dim),
}
ARGS = {
"target1": target1,
"target2": target2,
"attribute1": attribute1,
"attribute2": attribute2,
}
- 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 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
|
| boolean_string |
Ran ran, violated the contract we drafted |
anlausch/debie/exp_debiasnet_args.py pointer only (licence: NONE) · get_code("d481e95ca1390889") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, anlausch/debie 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. |
| create_duplicates |
Ran ran on a synthesized input |
nfriedri/debie-backend/calculation.py code served (permissive licence) · get_code("559fa36b836d0d46") 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 copy
import torch
import numpy as np
torch.manual_seed(0)
# The function uses copy.deepcopy on the arguments, so we need objects that can be deep copied
# Let's create various types of objects that are commonly used
# Simple tensor
set1_value = torch.randn(2, 4)
# Dictionary
set2_value = {
"weights": torch.randn(3, 4),
"bias": torch.randn(4),
"metadata": {"name": "layer1", "count": 5}
}
# List of mixed types
set3_value = [
torch.randn(2, 4),
np.array([1, 2, 3]),
{"key": "value"},
42
]
# Nested structure
set4_value = {
"tensors": [torch.randn(2, 3), torch.randn(3, 5)],
"arrays": np.array([[1, 2], [3, 4]]),
"nested": {
"inner_tensor": torch.randn(4, 2),
"inner_list": [1, 2, 3]
}
}
ARGS = {
"set1": set1_value,
"set2": set2_value,
"set3": set3_value,
"set4": set4_value
}
- 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
|
| dict_keys_to_string |
Ran ran on a synthesized input |
nfriedri/debie-backend/json_controller.py code served (permissive licence) · get_code("99bdfa1c386e0cc2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# The function iterates over vector_dict.keys() and converts each key to string
# It concatenates them with spaces, then removes the trailing space
# So vector_dict needs to be a dict with string-convertible keys
vector_dict = {
'embedding': torch.randn(2, 4),
'attention': torch.randn(3, 5),
'output': torch.randn(4, 6)
}
ARGS = {
'vector_dict': vector_dict
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| dict_to_json |
Ran ran on a synthesized input |
nfriedri/debie-backend/json_controller.py code served (permissive licence) · get_code("c21d9e8dd31a20a5") 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)
# The function iterates over keys in vector_dict and calls .tolist() on each value
# So vector_dict should be a dict mapping strings to torch tensors (or numpy arrays)
vector_dict = {
"word1": torch.randn(2, 4),
"word2": torch.randn(3, 5),
"word3": torch.randn(2, 6),
}
ARGS = {
"vector_dict": vector_dict
}
- 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
|
| eval_svm |
Ran ran on a synthesized input |
umanlp/debie-command-line/bias_evaluation/svm_classifier.py code served (permissive licence) · get_code("83515675d0094fcb") 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 logging
import random
import numpy as np
from sklearn import svm
logging.basicConfig(level=logging.INFO)
# Create a small vocabulary
vocab = {
'word1': 0,
'word2': 1,
'word3': 2,
'word4': 3,
'word5': 4,
'word6': 5,
'word7': 6,
'word8': 7,
}
# Create word vectors (embedding vectors for each word in vocab)
# Shape: (num_words, embedding_dim) = (8, 4)
vecs = np.random.randn(8, 4).astype(np.float32)
# Create augmentations (lists of words from the vocabulary)
augmentations1 = ['word1', 'word2', 'word3', 'word4']
augmentations2 = ['word5', 'word6', 'word7', 'word8']
# Create target sets (lists of words from the vocabulary)
target1 = ['word1', 'word2']
target2 = ['word5', 'word6']
ARGS = {
'augmentations1': augmentations1,
'augmentations2': augmentations2,
'target1': target1,
'target2': target2,
'vocab': vocab,
'vecs': vecs,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — 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
|
| format_set_sizes |
Ran ran on a synthesized input |
nfriedri/debie-backend/specification_controller.py code served (permissive licence) · get_code("ce02a6d9b77ea470") 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 logging
import random
logging.basicConfig(level=logging.INFO)
# The function expects two dictionaries that support:
# - len() operation
# - .keys() method
# - del operation
# - random.choice() on keys
# Create two dictionaries of different sizes
vector_set1 = {
'key_0': [1, 2, 3, 4],
'key_1': [5, 6, 7, 8],
'key_2': [9, 10, 11, 12],
'key_3': [13, 14, 15, 16],
'key_4': [17, 18, 19, 20],
}
vector_set2 = {
'vec_0': [21, 22, 23, 24],
'vec_1': [25, 26, 27, 28],
}
ARGS = {
'vector_set1': vector_set1,
'vector_set2': vector_set2,
}
- 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
|
| format_sets |
Ran ran on a synthesized input |
nfriedri/debie-backend/specification_controller.py code served (permissive licence) · get_code("33edd73c1410848f") 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 logging
import random
import torch
logging.basicConfig(level=logging.INFO)
# Set seed for reproducibility
torch.manual_seed(0)
random.seed(0)
# Create test dictionaries with different sizes
# vector_set1 will have 5 items
vector_set1_t = {
'key_0': torch.randn(4, 3),
'key_1': torch.randn(4, 3),
'key_2': torch.randn(4, 3),
'key_3': torch.randn(4, 3),
'key_4': torch.randn(4, 3),
}
# vector_set2 will have 3 items
vector_set2_t = {
'key_5': torch.randn(4, 3),
'key_6': torch.randn(4, 3),
'key_7': torch.randn(4, 3),
}
# vector_set1 will have 2 items
vector_set1_a = {
'key_8': torch.randn(4, 3),
'key_9': torch.randn(4, 3),
}
# vector_set2 will have 4 items
vector_set2_a = {
'key_10': torch.randn(4, 3),
'key_11': torch.randn(4, 3),
'key_12': torch.randn(4, 3),
'key_13': torch.randn(4, 3),
}
ARGS = {
't1': vector_set1_t,
't2': vector_set2_t,
'a1': vector_set1_a,
'a2': vector_set2_a,
}
- 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
|
| get_vector_from_small_dict |
Ran ran on a synthesized input |
nfriedri/debie-backend/Version0.1/compute_analogy.py code served (permissive licence) · get_code("bcfffd82f19b8867") 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 torch
torch.manual_seed(0)
dict1 = {
"word1": [1.0, 2.0, 3.0, 4.0],
"word2": [5.0, 6.0, 7.0, 8.0],
"word3": [9.0, 10.0, 11.0, 12.0]
}
ARGS = {
"dict1": dict1
}
- 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 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
|
| json_vector_retrieval |
Ran ran on a synthesized input |
nfriedri/debie-backend/json_controller.py code served (permissive licence) · get_code("0e30b32211028bc2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# The function json_vector_retrieval expects:
# 1. vector_dict: a dict where keys are words and values are numpy arrays or torch tensors with .tolist() method
# 2. not_found: a value that can be converted to string
# Create sample vector_dict with torch tensors
vector_dict = {
'hello': torch.tensor([1.0, 2.0, 3.0, 4.0]),
'world': torch.tensor([5.0, 6.0, 7.0, 8.0]),
'python': torch.tensor([9.0, 10.0, 11.0, 12.0])
}
# Create not_found list
not_found = ['unknown', 'missing', 'notfound']
ARGS = {
'vector_dict': vector_dict,
'not_found': not_found
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_binary_embeddings |
Ran ran on a synthesized input |
nfriedri/debie-backend/data_controller.py code served (permissive licence) · get_code("11c6271f3ac7fad6") 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 pickle
import numpy as np
import tempfile
import os
# Create temporary directory for test files
temp_dir = tempfile.mkdtemp()
# Create a small vocab pickle file
vocab = {'hello': 0, 'world': 1, 'test': 2, 'python': 3}
vocab_path = os.path.join(temp_dir, 'vocab.pkl')
with open(vocab_path, 'wb') as f:
pickle.dump(vocab, f)
# Create a small vectors numpy file
vecs = np.array([
[0.1, 0.2, 0.3, 0.4],
[0.5, 0.6, 0.7, 0.8],
[0.2, 0.3, 0.4, 0.5],
[0.9, 0.1, 0.2, 0.3]
], dtype=np.float32)
vecs_path = os.path.join(temp_dir, 'vecs.npy')
np.save(vecs_path, vecs)
# Define arguments for load_binary_embeddings
ARGS = {
'vocab_path': vocab_path,
'vecs_path': vecs_path,
'inverse': False,
'normalize': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_vectors_binary |
Ran ran on a synthesized input |
nfriedri/debie-backend/data_controller.py code served (permissive licence) · get_code("afd00edba761da8c") 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 (5, 8) 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 tempfile
import os
# Create a temporary directory and file for the test
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, "vectors.npy")
# Create a small sample numpy array and save it
sample_vecs = np.random.randn(5, 8).astype(np.float32)
np.save(temp_file, sample_vecs)
ARGS = {
"path": temp_file,
"normalize": False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (5, 8) — shape (5, 8) 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
|
| load_vocab_binary |
Ran ran on a synthesized input |
nfriedri/debie-backend/data_controller.py code served (permissive licence) · get_code("0f45921d6c72d3da") 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 directory for test files
temp_dir = tempfile.mkdtemp()
# Create a sample vocabulary dictionary
sample_vocab = {
'hello': 0,
'world': 1,
'foo': 2,
'bar': 3,
'baz': 4
}
# Save the vocabulary to a pickle file
vocab_path = os.path.join(temp_dir, 'vocab.pkl')
with open(vocab_path, 'wb') as f:
pickle.dump(sample_vocab, f)
# Define arguments for the function
ARGS = {
'path': vocab_path,
'inverse': False
}
- 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
|
| retrieve_vector_multiple |
Ran ran on a synthesized input |
nfriedri/debie-backend/vector_retrieval.py code served (permissive licence) · get_code("f5d190ff20783914") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# vocab: dict mapping words to indices
vocab = {
"hello": 0,
"world": 1,
"python": 2,
"test": 3
}
# vectors: tensor or array-like where vectors[i] gives the vector for word at index i
vectors = torch.randn(4, 4) # 4 words, 4-dimensional vectors
# word_list: list of words to retrieve vectors for
word_list = ["hello", "world", "unknown", "python"]
ARGS = {
"vocab": vocab,
"vectors": vectors,
"word_list": word_list
}
- 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
|
| retrieve_vector_single |
Ran ran on a synthesized input |
nfriedri/debie-backend/vector_retrieval.py code served (permissive licence) · get_code("261fa31e43f56cbc") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# vocab: dict mapping words (str) to indices (int)
vocab = {
"hello": 0,
"world": 1,
"python": 2
}
# vectors: tensor or array where vectors[i] gives the embedding for vocab word at index i
# Shape: (vocab_size, embedding_dim)
vectors = torch.randn(3, 4)
# target_word: str to look up
target_word = "hello"
ARGS = {
"vocab": vocab,
"vectors": vectors,
"target_word": target_word
}
- 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
|
| target_set_mean_vector |
Ran ran on a synthesized input |
umanlp/debie-command-line/bias_evaluation/ect.py code served (permissive licence) · get_code("549b1aad49e944c5") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (300,) 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
torch_manual_seed = 0
target_list = [
numpy.ones(300),
numpy.ones(300) * 2,
numpy.ones(300) * 3,
]
ARGS = {
"target_list": target_list,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family float, shape (300,) — shape (300,) 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
|
| transform_dict_to_list |
Ran ran on a synthesized input |
nfriedri/debie-backend/calculation.py code served (permissive licence) · get_code("ccdaa630046f3a52") 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
import torch
# The function takes a dictionary where values are array-like objects
# and converts them to a list of lists, then to a numpy array
# Create a simple dict with word keys and array-like values
dict1 = {
'word1': [1.0, 2.0, 3.0, 4.0],
'word2': [5.0, 6.0, 7.0, 8.0],
'word3': [9.0, 10.0, 11.0, 12.0]
}
ARGS = {
'dict1': dict1
}
- 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
|
| transform_multiple_dicts_to_lists |
Ran ran on a synthesized input |
nfriedri/debie-backend/calculation.py code served (permissive licence) · get_code("3e20da2273d79713") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy
# Create small dictionaries with word -> vector mappings
dict1 = {
"hello": [1.0, 2.0, 3.0, 4.0],
"world": [5.0, 6.0, 7.0, 8.0]
}
dict2 = {
"foo": [9.0, 10.0, 11.0, 12.0],
"bar": [13.0, 14.0, 15.0, 16.0]
}
dict3 = {
"alpha": [17.0, 18.0, 19.0, 20.0],
"beta": [21.0, 22.0, 23.0, 24.0]
}
dict4 = {
"one": [25.0, 26.0, 27.0, 28.0],
"two": [29.0, 30.0, 31.0, 32.0]
}
ARGS = {
"dict1": dict1,
"dict2": dict2,
"dict3": dict3,
"dict4": dict4
}
- 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 3, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_dict_uploaded_file |
Not yet run unverified (harvested, no recorded run) |
umanlp/debie-command-line/upload_controller.py code served (permissive licence) · get_code("cfc69051efee0623") How it ran |